ceph/src/boost/libs/multiprecision/test/ublas_interop/test42.cpp

   1 //
   2 //  Copyright (c) 2000-2002
   3 //  Joerg Walter, Mathias Koch
   4 //
   5 //  Distributed under the Boost Software License, Version 1.0. (See
   6 //  accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 //  The authors gratefully acknowledge the support of
  10 //  GeNeSys mbH & Co. KG in producing this work.
  11 //
  12
  13 #include "test4.hpp"
  14
  15 // Test matrix & vector expression templates
  16 template<class V, class M, int N>
  17 struct test_my_matrix_vector {
  18     typedef typename V::value_type value_type;
  19
  20     template<class VP, class MP>
  21     void test_with (VP &v1, VP &v2, MP &m1) const {
  22         {
  23 #ifndef USE_DIAGONAL
  24             // Rows and columns
  25             initialize_matrix (m1);
  26             for (int i = 0; i < N; ++ i) {
  27                 v2 = ublas::row (m1, i);
  28                 std::cout << "row (m, " << i << ") = " << v2 << std::endl;
  29                 v2 = ublas::column (m1, i);
  30                 std::cout << "column (m, " << i << ") = " << v2 << std::endl;
  31             }
  32
  33             // Outer product
  34             initialize_vector (v1);
  35             initialize_vector (v2);
  36             v1 (0) = 0;
  37             v1 (N - 1) = 0;
  38             m1 = ublas::outer_prod (v1, v2);
  39             std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
  40
  41             // Matrix vector product
  42             initialize_matrix (m1);
  43             initialize_vector (v1);
  44             v2 = ublas::prod (m1, v1);
  45             std::cout << "prod (m1, v1) = " << v2 << std::endl;
  46             v2 = ublas::prod (v1, m1);
  47             std::cout << "prod (v1, m1) = " << v2 << std::endl;
  48 #endif
  49         }
  50     }
  51     void operator () () const {
  52         {
  53             V v1 (N), v2 (N);
  54 #ifdef USE_BANDED
  55             M m1 (N, N, 1, 1);
  56 #endif
  57 #ifdef USE_DIAGONAL
  58             M m1 (N, N);
  59 #endif
  60             test_with (v1, v2, m1);
  61
  62             ublas::matrix_row<M> mr1 (m1, 1), mr2 (m1, 1);
  63             test_with (mr1, mr2, m1);
  64
  65             ublas::matrix_column<M> mc1 (m1, 1), mc2 (m1, 1);
  66             test_with (mc1, mc2, m1);
  67
  68 #ifdef USE_RANGE
  69             ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
  70                                           mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
  71             test_with (mvr1, mvr2, m1);
  72 #endif
  73
  74 #ifdef USE_SLICE
  75             ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
  76                                           mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
  77             test_with (mvs1, mvs2, m1);
  78 #endif
  79         }
  80     }
  81
  82     void operator () (int) const {
  83 #ifdef USE_ADAPTOR
  84         {
  85 #ifdef USE_BANDED
  86             V v1 (N), v2 (N);
  87             M m1 (N, N, 1, 1);
  88             ublas::banded_adaptor<M> bam1 (m1, 1, 1);
  89             test_with (v1, v2, bam1);
  90
  91             ublas::matrix_row<ublas::banded_adaptor<M> > mr1 (bam1, 1), mr2 (bam1, 1);
  92             test_with (mr1, mr2, bam1);
  93
  94             ublas::matrix_column<ublas::banded_adaptor<M> > mc1 (bam1, 1), mc2 (bam1, 1);
  95             test_with (mc1, mc2, bam1);
  96
  97 #ifdef USE_RANGE
  98             ublas::matrix_vector_range<ublas::banded_adaptor<M> > mvr1 (bam1, ublas::range (0, N), ublas::range (0, N)),
  99                                                                   mvr2 (bam1, ublas::range (0, N), ublas::range (0, N));
 100             test_with (mvr1, mvr2, bam1);
 101 #endif
 102
 103 #ifdef USE_SLICE
 104             ublas::matrix_vector_slice<ublas::banded_adaptor<M> > mvs1 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
 105                                                                   mvs2 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
 106             test_with (mvs1, mvs2, bam1);
 107 #endif
 108 #endif
 109 #ifdef USE_DIAGONAL
 110             V v1 (N), v2 (N);
 111             M m1 (N, N);
 112             ublas::diagonal_adaptor<M> dam1 (m1);
 113             test_with (v1, v2, dam1);
 114
 115             ublas::matrix_row<ublas::diagonal_adaptor<M> > mr1 (dam1, 1), mr2 (dam1, 1);
 116             test_with (mr1, mr2, dam1);
 117
 118             ublas::matrix_column<ublas::diagonal_adaptor<M> > mc1 (dam1, 1), mc2 (dam1, 1);
 119             test_with (mc1, mc2, dam1);
 120
 121 #ifdef USE_RANGE
 122             ublas::matrix_vector_range<ublas::diagonal_adaptor<M> > mvr1 (dam1, ublas::range (0, N), ublas::range (0, N)),
 123                                                                     mvr2 (dam1, ublas::range (0, N), ublas::range (0, N));
 124             test_with (mvr1, mvr2, dam1);
 125 #endif
 126
 127 #ifdef USE_SLICE
 128             ublas::matrix_vector_slice<ublas::diagonal_adaptor<M> > mvs1 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
 129                                                                     mvs2 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
 130             test_with (mvs1, mvs2, dam1);
 131 #endif
 132 #endif
 133         }
 134 #endif
 135     }
 136 };
 137
 138 // Test matrix & vector
 139 void test_matrix_vector () {
 140     std::cout << "test_matrix_vector" << std::endl;
 141
 142 #ifdef USE_BANDED
 143 #ifdef USE_BOUNDED_ARRAY
 144 #ifdef USE_FLOAT
 145     std::cout << "mp_test_type, bounded_array" << std::endl;
 146     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
 147                           ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
 148     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
 149                           ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
 150 #endif
 151
 152 #ifdef USE_DOUBLE
 153     std::cout << "double, bounded_array" << std::endl;
 154     test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
 155                           ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
 156     test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
 157                           ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
 158 #endif
 159
 160 #ifdef USE_STD_COMPLEX
 161 #ifdef USE_FLOAT
 162     std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
 163     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
 164                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
 165     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
 166                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
 167 #endif
 168
 169 #ifdef USE_DOUBLE
 170     std::cout << "std::complex<double>, bounded_array" << std::endl;
 171     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
 172                           ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
 173     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
 174                           ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
 175 #endif
 176 #endif
 177 #endif
 178
 179 #ifdef USE_UNBOUNDED_ARRAY
 180 #ifdef USE_FLOAT
 181     std::cout << "mp_test_type, unbounded_array" << std::endl;
 182     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
 183                           ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
 184     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
 185                           ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
 186 #endif
 187
 188 #ifdef USE_DOUBLE
 189     std::cout << "double, unbounded_array" << std::endl;
 190     test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
 191                           ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
 192     test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
 193                           ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
 194 #endif
 195
 196 #ifdef USE_STD_COMPLEX
 197 #ifdef USE_FLOAT
 198     std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
 199     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
 200                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
 201     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
 202                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
 203 #endif
 204
 205 #ifdef USE_DOUBLE
 206     std::cout << "std::complex<double>, unbounded_array" << std::endl;
 207     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
 208                           ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
 209     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
 210                           ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
 211 #endif
 212 #endif
 213 #endif
 214
 215 #ifdef USE_STD_VECTOR
 216 #ifdef USE_FLOAT
 217     std::cout << "mp_test_type, std::vector" << std::endl;
 218     test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
 219                           ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
 220     test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
 221                           ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
 222 #endif
 223
 224 #ifdef USE_DOUBLE
 225     std::cout << "double, std::vector" << std::endl;
 226     test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
 227                           ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3> () ();
 228     test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
 229                           ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3> () (0);
 230 #endif
 231
 232 #ifdef USE_STD_COMPLEX
 233 #ifdef USE_FLOAT
 234     std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
 235     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
 236                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
 237     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
 238                           ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
 239 #endif
 240
 241 #ifdef USE_DOUBLE
 242     std::cout << "std::complex<double>, std::vector" << std::endl;
 243     test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
 244                           ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
 245     test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
 246                           ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
 247 #endif
 248 #endif
 249 #endif
 250 #endif
 251
 252 #ifdef USE_DIAGONAL
 253 #ifdef USE_BOUNDED_ARRAY
 254 #ifdef USE_FLOAT
 255     std::cout << "mp_test_type, bounded_array" << std::endl;
 256     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
 257                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
 258     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
 259                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
 260 #endif
 261
 262 #ifdef USE_DOUBLE
 263     std::cout << "double, bounded_array" << std::endl;
 264     test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
 265                           ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
 266     test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
 267                           ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
 268 #endif
 269
 270 #ifdef USE_STD_COMPLEX
 271 #ifdef USE_FLOAT
 272     std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
 273     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
 274                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
 275     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
 276                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
 277 #endif
 278
 279 #ifdef USE_DOUBLE
 280     std::cout << "std::complex<double>, bounded_array" << std::endl;
 281     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
 282                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
 283     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
 284                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
 285 #endif
 286 #endif
 287 #endif
 288
 289 #ifdef USE_UNBOUNDED_ARRAY
 290 #ifdef USE_FLOAT
 291     std::cout << "mp_test_type, unbounded_array" << std::endl;
 292     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
 293                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
 294     test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
 295                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
 296 #endif
 297
 298 #ifdef USE_DOUBLE
 299     std::cout << "double, unbounded_array" << std::endl;
 300     test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
 301                           ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
 302     test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
 303                           ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
 304 #endif
 305
 306 #ifdef USE_STD_COMPLEX
 307 #ifdef USE_FLOAT
 308     std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
 309     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
 310                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
 311     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
 312                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
 313 #endif
 314
 315 #ifdef USE_DOUBLE
 316     std::cout << "std::complex<double>, unbounded_array" << std::endl;
 317     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
 318                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
 319     test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
 320                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
 321 #endif
 322 #endif
 323 #endif
 324
 325 #ifdef USE_STD_VECTOR
 326 #ifdef USE_FLOAT
 327     std::cout << "mp_test_type, std::vector" << std::endl;
 328     test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
 329                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
 330     test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
 331                           ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
 332 #endif
 333
 334 #ifdef USE_DOUBLE
 335     std::cout << "double, std::vector" << std::endl;
 336     test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
 337                           ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3> () ();
 338     test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
 339                           ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3> () (0);
 340 #endif
 341
 342 #ifdef USE_STD_COMPLEX
 343 #ifdef USE_FLOAT
 344     std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
 345     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
 346                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
 347     test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
 348                           ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
 349 #endif
 350
 351 #ifdef USE_DOUBLE
 352     std::cout << "std::complex<double>, std::vector" << std::endl;
 353     test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
 354                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
 355     test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
 356                           ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
 357 #endif
 358 #endif
 359 #endif
 360 #endif
 361 }