ceph/src/boost/libs/numeric/ublas/benchmarks/bench2/bench2.hpp

   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 #ifndef BENCH2_H
  14 #define BENCH2_H
  15
  16 #include <iostream>
  17 #include <string>
  18 #include <valarray>
  19
  20 #include <boost/numeric/ublas/vector.hpp>
  21 #include <boost/numeric/ublas/vector_sparse.hpp>
  22 #include <boost/numeric/ublas/matrix.hpp>
  23 #include <boost/numeric/ublas/matrix_sparse.hpp>
  24
  25 #include <boost/timer.hpp>
  26
  27
  28 #define BOOST_UBLAS_NOT_USED(x) (void)(x)
  29
  30
  31 namespace ublas = boost::numeric::ublas;
  32
  33 void header (std::string text);
  34
  35 template<class T>
  36 struct footer {
  37     void operator () (int multiplies, int plus, int runs, double elapsed) {
  38         std::cout << "elapsed: " << elapsed << " s, "
  39                   << (multiplies * ublas::type_traits<T>::multiplies_complexity +
  40                       plus * ublas::type_traits<T>::plus_complexity) * runs /
  41                      (1024 * 1024 * elapsed) << " Mflops" << std::endl;
  42     }
  43 };
  44
  45 template<class T, int N>
  46 struct c_vector_traits {
  47     typedef T type [N];
  48 };
  49 template<class T, int N, int M>
  50 struct c_matrix_traits {
  51     typedef T type [N] [M];
  52 };
  53
  54 template<class T, int N>
  55 struct initialize_c_vector  {
  56     void operator () (typename c_vector_traits<T, N>::type &v) {
  57         for (int i = 0; i < N; ++ i)
  58             v [i] = std::rand () * 1.f;
  59 //            v [i] = 0.f;
  60         }
  61 };
  62 template<class V>
  63 BOOST_UBLAS_INLINE
  64 void initialize_vector (V &v) {
  65     int size = v.size ();
  66     for (int i = 0; i < size; ++ i)
  67         v [i] = std::rand () * 1.f;
  68 //        v [i] = 0.f;
  69 }
  70
  71 template<class T, int N, int M>
  72 struct initialize_c_matrix  {
  73     void operator () (typename c_matrix_traits<T, N, M>::type &m) {
  74         for (int i = 0; i < N; ++ i)
  75             for (int j = 0; j < M; ++ j)
  76                 m [i] [j] = std::rand () * 1.f;
  77 //                m [i] [j] = 0.f;
  78     }
  79 };
  80 template<class M>
  81 BOOST_UBLAS_INLINE
  82 void initialize_matrix (M &m, ublas::row_major_tag) {
  83     int size1 = m.size1 ();
  84     int size2 = m.size2 ();
  85     for (int i = 0; i < size1; ++ i)
  86         for (int j = 0; j < size2; ++ j)
  87             m (i, j) = std::rand () * 1.f;
  88 //            m (i, j) = 0.f;
  89 }
  90 template<class M>
  91 BOOST_UBLAS_INLINE
  92 void initialize_matrix (M &m, ublas::column_major_tag) {
  93     int size1 = m.size1 ();
  94     int size2 = m.size2 ();
  95     for (int j = 0; j < size2; ++ j)
  96         for (int i = 0; i < size1; ++ i)
  97             m (i, j) = std::rand () * 1.f;
  98 //            m (i, j) = 0.f;
  99 }
 100 template<class M>
 101 BOOST_UBLAS_INLINE
 102 void initialize_matrix (M &m) {
 103     typedef typename M::orientation_category orientation_category;
 104     initialize_matrix (m, orientation_category ());
 105 }
 106
 107 template<class T>
 108 BOOST_UBLAS_INLINE
 109 void sink_scalar (const T &s) {
 110     static T g_s = s;
 111 }
 112
 113 template<class T, int N>
 114 struct sink_c_vector {
 115     void operator () (const typename c_vector_traits<T, N>::type &v) {
 116         static typename c_vector_traits<T, N>::type g_v;
 117         for (int i = 0; i < N; ++ i)
 118             g_v [i] = v [i];
 119     }
 120 };
 121 template<class V>
 122 BOOST_UBLAS_INLINE
 123 void sink_vector (const V &v) {
 124     static V g_v (v);
 125 }
 126
 127 template<class T, int N, int M>
 128 struct sink_c_matrix {
 129     void operator () (const typename c_matrix_traits<T, N, M>::type &m) {
 130     static typename c_matrix_traits<T, N, M>::type g_m;
 131     for (int i = 0; i < N; ++ i)
 132         for (int j = 0; j < M; ++ j)
 133             g_m [i] [j] = m [i] [j];
 134     }
 135 };
 136 template<class M>
 137 BOOST_UBLAS_INLINE
 138 void sink_matrix (const M &m) {
 139     static M g_m (m);
 140 }
 141
 142 template<class T>
 143 struct peak {
 144     void operator () (int runs);
 145 };
 146
 147 template<class T, int N>
 148 struct bench_1 {
 149     void operator () (int runs);
 150 };
 151
 152 template<class T, int N>
 153 struct bench_2 {
 154     void operator () (int runs);
 155 };
 156
 157 template<class T, int N>
 158 struct bench_3 {
 159     void operator () (int runs);
 160 };
 161
 162 struct safe_tag {};
 163 struct fast_tag {};
 164
 165 // #define USE_FLOAT
 166 #define USE_DOUBLE
 167 // #define USE_STD_COMPLEX
 168
 169 #define USE_MAP_ARRAY
 170 // #define USE_STD_MAP
 171 // #define USE_STD_VALARRAY
 172
 173 #define USE_MAPPED_VECTOR
 174 #define USE_COMPRESSED_VECTOR
 175 #define USE_COORDINATE_VECTOR
 176
 177 #define USE_MAPPED_MATRIX
 178 // #define USE_SPARSE_VECTOR_OF_SPARSE_VECTOR
 179 #define USE_COMPRESSED_MATRIX
 180 #define USE_COORDINATE_MATRIX
 181
 182 #endif