Program Listing for File DenseMatrix.h

↰ Return to documentation for file (ADS/numeric/DenseMatrix.h)

/*--------------------------------------------------------------------------*/
/*--------------------------- File DenseMatrix.h ---------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/

#ifndef __ADS_DenseMatrix
 #define __ADS_DenseMatrix
                      /* self-identification: #endif constant */

/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/Contract.h"
#include "ADS/numeric/Matrix.h"

#include <algorithm>
#include <cstddef>
#include <cstring>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include <vector>

#if defined( __AVX512F__ ) || ( defined( __AVX2__ ) && defined( __FMA__ ) )
 #include <immintrin.h>
#endif

/*--------------------------------------------------------------------------*/
/*--------------------------- NAMESPACE ------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace ADS {

namespace detail {

template< class U >
struct DefaultInitAllocator : std::allocator< U > {
 using value_type = U;
 template< class V >
 struct rebind { using other = DefaultInitAllocator< V >; };
 DefaultInitAllocator( void ) = default;
 template< class V >
 DefaultInitAllocator( const DefaultInitAllocator< V > & ) noexcept {}
 template< class V >
 void construct( V * p ) noexcept( std::is_nothrow_default_constructible_v<
                                    V > ) {
  ::new( static_cast< void * >( p ) ) V;
  }
 template< class V , class ... Args >
 void construct( V * p , Args && ... args ) {
  ::new( static_cast< void * >( p ) ) V( std::forward< Args >( args )... );
  }
 };

}  // end( namespace detail )

/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS DenseMatrix ----------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
class DenseMatrix {
 public:
 using value_type = T;

 DenseMatrix( void ) = default;

 DenseMatrix( std::size_t m , std::size_t n , const T & v = T( 0 ) )
  : f_m( m ) , f_n( n ) , f_A( m * n ) {
  std::fill( f_A.begin() , f_A.end() , v );
  }

 static DenseMatrix uninitialized( std::size_t m , std::size_t n ) {
  DenseMatrix M;
  M.f_m = m;
  M.f_n = n;
  M.f_A.resize( m * n );
  return( M );
  }

 explicit DenseMatrix( const Matrix< T > & A );

 [[nodiscard]] std::size_t rows( void ) const { return( f_m ); }
 [[nodiscard]] std::size_t cols( void ) const { return( f_n ); }

 [[nodiscard]] T & operator()( std::size_t i , std::size_t j ) {
  ADS_PRE( ( i < f_m ) && ( j < f_n ) );
  return( f_A[ i * f_n + j ] );
  }
 [[nodiscard]] const T & operator()( std::size_t i , std::size_t j ) const {
  ADS_PRE( ( i < f_m ) && ( j < f_n ) );
  return( f_A[ i * f_n + j ] );
  }

 [[nodiscard]] T * data( void ) { return( f_A.data() ); }
 [[nodiscard]] const T * data( void ) const { return( f_A.data() ); }

 [[nodiscard]] Matrix< T > toMatrix( void ) const;

 bool operator==( const DenseMatrix & ) const = default;

 private:
 std::size_t f_m = 0 , f_n = 0;
 std::vector< T , detail::DefaultInitAllocator< T > > f_A;
 };  // end( class DenseMatrix )

/*--------------------------------------------------------------------------*/
/*------------------------------ FUNCTIONS ---------------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
void gemm( std::size_t m , std::size_t n , std::size_t k , T alpha ,
           const T * A , std::size_t lda , const T * B , std::size_t ldb ,
           T beta , T * C , std::size_t ldc );

template< class T >
DenseMatrix< T > multiply( const DenseMatrix< T > & A ,
                           const DenseMatrix< T > & B );

template< class T >
DenseMatrix< T > transpose( const DenseMatrix< T > & A );

template< class T >
DenseMatrix< T > multiplyStrassen( const DenseMatrix< T > & A ,
                                   const DenseMatrix< T > & B ,
                                   std::size_t cutoff = 3072 );

/*--------------------------------------------------------------------------*/

}  // end( namespace ADS )

/*--------------------------------------------------------------------------*/
/*-------------------------- IMPLEMENTATION --------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/numeric/impl/DenseMatrix.tpp"

/*--------------------------------------------------------------------------*/

#endif  /* DenseMatrix.h included */

/*--------------------------------------------------------------------------*/
/*------------------------- End File DenseMatrix.h -------------------------*/
/*--------------------------------------------------------------------------*/