include/algebramix/matrix_int.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : matrix_int.hpp
* DESCRIPTION: matrices over hardware integers
* COPYRIGHT  : (C) 2009  Gregoire Lecerf
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX_MATRIX_INT_HPP
#define __MMX_MATRIX_INT_HPP
#include <basix/int.hpp>
#include <algebramix/vector_unrolled.hpp>
#include <algebramix/vector_simd.hpp>
#include <algebramix/matrix.hpp>
#include <algebramix/matrix_ring_naive.hpp>
#include <algebramix/matrix_strassen.hpp>
#include <algebramix/matrix_threads.hpp>
#include <algebramix/matrix_simd.hpp>
#include <algebramix/matrix_sse.hpp>
namespace mmx {
#define TMPL template<typename V>
#define Matrix matrix<int,V>

/******************************************************************************
* Special case for matrix<int>
******************************************************************************/

TMPL inline Matrix operator + (const Matrix& x, const int& y) {
  return x + promote (y, x); }
TMPL inline Matrix operator + (const int& x, const Matrix& y) {
  return promote (x, y) + y; }
TMPL inline Matrix operator - (const Matrix& x, const int& y) {
  return x - promote (y, x); }
TMPL inline Matrix operator - (const int& x, const Matrix& y) {
  return promote (x, y) - y; }
TMPL inline Matrix operator * (const Matrix& x, const int& y) {
  return x * promote (y, x); }
TMPL inline Matrix operator * (const int& x, const Matrix& y) {
  return promote (x, y) * y; }
TMPL inline Matrix operator / (const Matrix& x, const int& y) {
  return x / promote (y, x); }
TMPL inline Matrix operator / (const int& x, const Matrix& y) {
  return promote (x, y) / y; }

#undef TMPL
#undef Matrix

/******************************************************************************
* Roughly 'optimized' variants for an '__SSE2__' Intel processor
******************************************************************************/

DEFINE_VARIANT_1 (typename I, I, matrix_int_simd,
                  matrix_ring_naive<
                    matrix_strassen<
                      matrix_threads<
                        typename Matrix_simd_variant(I) > > >)

DEFINE_VARIANT (matrix_int,
                matrix_ring_naive<
                  matrix_strassen<
                    matrix_threads<
                      matrix_unrolled<4> > > >)

#if defined(BASIX_HAVE_STDINT_H)
STMPL
struct matrix_variant_helper<int8_t> {
  typedef matrix_int_simd<int8_t> MV; };
STMPL
struct matrix_variant_helper<uint8_t> {
  typedef matrix_int_simd<uint8_t> MV; };
STMPL
struct matrix_variant_helper<int16_t> {
  typedef matrix_int_simd<int16_t> MV; };
STMPL
struct matrix_variant_helper<uint16_t> {
  typedef matrix_int_simd<uint16_t> MV; };
STMPL
struct matrix_variant_helper<int32_t> {
  typedef matrix_int_simd<int32_t> MV; };
STMPL
struct matrix_variant_helper<uint32_t> {
  typedef matrix_int_simd<uint32_t> MV; };
STMPL
struct matrix_variant_helper<int64_t> {
  typedef matrix_int MV; };
STMPL
struct matrix_variant_helper<uint64_t> {
  typedef matrix_int MV; };
#else
STMPL
struct matrix_variant_helper<signed char> {
  typedef matrix_int_simd<signed char> MV; };
STMPL
struct matrix_variant_helper<unsigned char> {
  typedef matrix_int_simd<unsigned char> MV; };
STMPL
struct matrix_variant_helper<signed short> {
  typedef matrix_int_simd<signed short> MV; };
STMPL
struct matrix_variant_helper<unsigned short> {
  typedef matrix_int_simd<unsigned short> MV; };
STMPL
struct matrix_variant_helper<int> {
  typedef matrix_int_simd<int> MV; };
STMPL
struct matrix_variant_helper<unsigned int> {
  typedef matrix_int_simd<unsigned int> MV; };
STMPL
struct matrix_variant_helper<long int> {
  typedef matrix_int MV; };
STMPL
struct matrix_variant_helper<unsigned long int> {
  typedef matrix_int MV; };
STMPL
struct matrix_variant_helper<long long int> {
  typedef matrix_int MV; };
STMPL
struct matrix_variant_helper<unsigned long long int> {
  typedef matrix_int MV; };
#endif

#if defined(BASIX_HAVE_INT128) && defined(BASIX_HAVE_STDINT_H)
STMPL
struct matrix_variant_helper<__int128> {
  typedef matrix_int MV; };
STMPL
struct matrix_variant_helper<unsigned __int128> {
  typedef matrix_int MV; };
#endif

/******************************************************************************
* Thresholds
******************************************************************************/

template<typename V>
struct threshold_helper<signed char,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,2048> impl;
};

template<typename V>
struct threshold_helper<unsigned char,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,2048> impl;
};

template<typename V>
struct threshold_helper<short int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,1024> impl;
};

template<typename V>
struct threshold_helper<unsigned short int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,1024> impl;
};

template<typename V>
struct threshold_helper<int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

template<typename V>
struct threshold_helper<unsigned int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

template<typename V>
struct threshold_helper<long int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

template<typename V>
struct threshold_helper<unsigned long int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

template<typename V>
struct threshold_helper<long long int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

template<typename V>
struct threshold_helper<unsigned long long int,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,512> impl;
};

#if defined(BASIX_HAVE_INT128) && defined(BASIX_HAVE_STDINT_H)
template<typename V>
struct threshold_helper<__int128,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,256> impl;
};

template<typename V>
struct threshold_helper<unsigned __int128,
                        matrix_multiply_threshold<matrix_strassen<V> > > {
  typedef fixed_value<nat,256> impl;
};
#endif

} // namespace mmx
#endif // __MMX_MATRIX_INT_HPP

---