fixedSizeSquareMatrixOps.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

#include "genericTensorOps.hpp"
#include "fixedSizeSquareMatrixOpsImpl.hpp"

namespace LvArray
{
namespace tensorOps
{


template< std::ptrdiff_t M, typename MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto determinant( MATRIX const & matrix )
{ return internal::SquareMatrixOps< M >::determinant( matrix ); }

template< std::ptrdiff_t M, typename DST_MATRIX, typename SRC_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto invert( DST_MATRIX && LVARRAY_RESTRICT_REF dstMatrix,
             SRC_MATRIX const & LVARRAY_RESTRICT_REF srcMatrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( dstMatrix[ 0 ][ 0 ] ) > >::value,
                 "The destination matrix must be contain floating point values." );
  return internal::SquareMatrixOps< M >::invert( std::forward< DST_MATRIX >( dstMatrix ), srcMatrix );
}

template< std::ptrdiff_t M, typename MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto invert( MATRIX && matrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( matrix[ 0 ][ 0 ] ) > >::value,
                 "The matrix must be contain floating point values." );
  return internal::SquareMatrixOps< M >::invert( std::forward< MATRIX >( matrix ) );
}



template< std::ptrdiff_t M, typename DST_VECTOR, typename SYM_MATRIX_A, typename VECTOR_B >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void Ri_eq_symAijBj( DST_VECTOR && LVARRAY_RESTRICT_REF dstVector,
                     SYM_MATRIX_A const & LVARRAY_RESTRICT_REF symMatrixA,
                     VECTOR_B const & LVARRAY_RESTRICT_REF vectorB )
{
  internal::SquareMatrixOps< M >::Ri_eq_symAijBj( std::forward< DST_VECTOR >( dstVector ),
                                                  symMatrixA,
                                                  vectorB );
}

template< std::ptrdiff_t M, typename DST_VECTOR, typename SYM_MATRIX_A, typename VECTOR_B >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void Ri_add_symAijBj( DST_VECTOR && LVARRAY_RESTRICT_REF dstVector,
                      SYM_MATRIX_A const & LVARRAY_RESTRICT_REF symMatrixA,
                      VECTOR_B const & LVARRAY_RESTRICT_REF vectorB )
{
  internal::SquareMatrixOps< M >::Ri_add_symAijBj( std::forward< DST_VECTOR >( dstVector ),
                                                   symMatrixA,
                                                   vectorB );
}

template< std::ptrdiff_t M, typename DST_MATRIX, typename SYM_MATRIX_A, typename MATRIX_B >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void Rij_eq_symAikBjk( DST_MATRIX && LVARRAY_RESTRICT_REF dstMatrix,
                       SYM_MATRIX_A const & LVARRAY_RESTRICT_REF symMatrixA,
                       MATRIX_B const & LVARRAY_RESTRICT_REF matrixB )
{
  internal::SquareMatrixOps< M >::Rij_eq_symAikBjk( std::forward< DST_MATRIX >( dstMatrix ),
                                                    symMatrixA,
                                                    matrixB );
}

template< std::ptrdiff_t M, typename DST_SYM_MATRIX, typename MATRIX_A, typename SYM_MATRIX_B >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void Rij_eq_AikSymBklAjl( DST_SYM_MATRIX && LVARRAY_RESTRICT_REF dstSymMatrix,
                          MATRIX_A const & LVARRAY_RESTRICT_REF matrixA,
                          SYM_MATRIX_B const & LVARRAY_RESTRICT_REF symMatrixB )
{
  internal::SquareMatrixOps< M >::Rij_eq_AikSymBklAjl( std::forward< DST_SYM_MATRIX >( dstSymMatrix ),
                                                       matrixA,
                                                       symMatrixB );
}


template< std::ptrdiff_t M, typename DST_SYM_MATRIX, typename VECTOR_A >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void symRij_eq_AiAj( DST_SYM_MATRIX && LVARRAY_RESTRICT_REF dstMatrix,
                     VECTOR_A const & LVARRAY_RESTRICT_REF vectorA )
{
  internal::SquareMatrixOps< M >::symRij_eq_AiAj( std::forward< DST_SYM_MATRIX >( dstMatrix ),
                                                  vectorA );
}

template< std::ptrdiff_t M, typename DST_SYM_MATRIX, typename VECTOR_A, typename VECTOR_B >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void symRij_eq_AiBj_plus_AjBi( DST_SYM_MATRIX && LVARRAY_RESTRICT_REF dstMatrix,
                               VECTOR_A const & LVARRAY_RESTRICT_REF vectorA,
                               VECTOR_B const & LVARRAY_RESTRICT_REF vectorB )
{
  internal::SquareMatrixOps< M >::symRij_eq_AiBj_plus_AjBi( std::forward< DST_SYM_MATRIX >( dstMatrix ),
                                                            vectorA,
                                                            vectorB );
}


template< std::ptrdiff_t M, typename SYM_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto symDeterminant( SYM_MATRIX const & symMatrix )
{ return internal::SquareMatrixOps< M >::symDeterminant( symMatrix ); }

template< std::ptrdiff_t M, typename DST_SYM_MATRIX, typename SRC_SYM_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto symInvert( DST_SYM_MATRIX && LVARRAY_RESTRICT_REF dstSymMatrix,
                SRC_SYM_MATRIX const & LVARRAY_RESTRICT_REF srcSymMatrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( dstSymMatrix[ 0 ] ) > >::value,
                 "The destination matrix must be contain floating point values." );
  return internal::SquareMatrixOps< M >::symInvert( std::forward< DST_SYM_MATRIX >( dstSymMatrix ), srcSymMatrix );
}

template< std::ptrdiff_t M, typename SYM_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
auto symInvert( SYM_MATRIX && symMatrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( symMatrix[ 0 ] ) > >::value,
                 "The matrix must be contain floating point values." );
  return internal::SquareMatrixOps< M >::symInvert( std::forward< SYM_MATRIX >( symMatrix ) );
}

template< std::ptrdiff_t M, typename DST_VECTOR, typename SYM_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void symEigenvalues( DST_VECTOR && LVARRAY_RESTRICT_REF eigenvalues,
                     SYM_MATRIX const & LVARRAY_RESTRICT_REF symMatrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( eigenvalues[ 0 ] ) > >::value,
                 "eigenvalues must be contain floating point values." );
  internal::SquareMatrixOps< M >::symEigenvalues( std::forward< DST_VECTOR >( eigenvalues ), symMatrix );
}

template< std::ptrdiff_t M, typename DST_VECTOR, typename DST_MATRIX, typename SYM_MATRIX >
LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
void symEigenvectors( DST_VECTOR && LVARRAY_RESTRICT_REF eigenvalues,
                      DST_MATRIX && LVARRAY_RESTRICT_REF eigenvectors,
                      SYM_MATRIX const & LVARRAY_RESTRICT_REF symMatrix )
{
  static_assert( std::is_floating_point< std::decay_t< decltype( eigenvalues[ 0 ] ) > >::value,
                 "eigenvalues must be contain floating point values." );
  static_assert( std::is_floating_point< std::decay_t< decltype( eigenvectors[ 0 ][ 0 ] ) > >::value,
                 "eigenvectors must be contain floating point values." );
  internal::SquareMatrixOps< M >::symEigenvectors( std::forward< DST_VECTOR >( eigenvalues ),
                                                   std::forward< DST_MATRIX >( eigenvectors ),
                                                   symMatrix );
}

template< std::ptrdiff_t M, typename DST_SYM_MATRIX, typename SRC_MATRIX >
LVARRAY_HOST_DEVICE constexpr inline
void denseToSymmetric( DST_SYM_MATRIX && dstSymMatrix, SRC_MATRIX const & srcMatrix )
{
  return internal::SquareMatrixOps< M >::denseToSymmetric( std::forward< DST_SYM_MATRIX >( dstSymMatrix ),
                                                           srcMatrix );
}

template< std::ptrdiff_t M, typename DST_MATRIX, typename SRC_SYM_MATRIX >
LVARRAY_HOST_DEVICE constexpr inline
void symmetricToDense( DST_MATRIX && dstMatrix, SRC_SYM_MATRIX const & srcSymMatrix )
{
  return internal::SquareMatrixOps< M >::symmetricToDense( std::forward< DST_MATRIX >( dstMatrix ),
                                                           srcSymMatrix );
}


} // namespace tensorOps
} // namespace LvArray