blas_matrix.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/backend/backend.hpp>
#include <uni20/common/trace.hpp>
#include <uni20/core/scalar_concepts.hpp>
 
#include <utility>
 
namespace uni20::linalg::blas
{
 
enum class MatrixTransform : unsigned
{
  normal = 0U,
  transpose = 1U,
  conjugate = 2U,
  conjugate_transpose = 3U
};
 
namespace detail
{
constexpr unsigned transform_mask = std::to_underlying(MatrixTransform::conjugate_transpose);
constexpr unsigned transpose_bit = std::to_underlying(MatrixTransform::transpose);
constexpr unsigned conjugate_bit = std::to_underlying(MatrixTransform::conjugate);
 
constexpr void require_valid_transform(MatrixTransform transform)
{
  if (std::to_underlying(transform) > transform_mask)
  {
    PANIC("invalid MatrixTransform", std::to_underlying(transform));
  }
}
} // namespace detail
 
constexpr bool swaps_axes(MatrixTransform transform)
{
  return (std::to_underlying(transform) & detail::transpose_bit) != 0U;
}
 
constexpr bool conjugates_values(MatrixTransform transform)
{
  return (std::to_underlying(transform) & detail::conjugate_bit) != 0U;
}
 
constexpr MatrixTransform compose(MatrixTransform outer, MatrixTransform inner)
{
  return static_cast<MatrixTransform>((std::to_underlying(outer) ^ std::to_underlying(inner)) & detail::transform_mask);
}
 
constexpr MatrixTransform transpose_result_transform(MatrixTransform transform)
{
  return compose(MatrixTransform::transpose, transform);
}
 
template <uni20::BlasScalar Scalar> constexpr MatrixTransform canonical_transform_for_scalar(MatrixTransform transform)
{
  detail::require_valid_transform(transform);
  if constexpr (uni20::is_complex_v<Scalar>)
  {
    return transform;
  }
  else
  {
    return static_cast<MatrixTransform>(std::to_underlying(transform) & detail::transpose_bit);
  }
}
 
template <uni20::BlasScalar Scalar> constexpr bool blas_trans_char_is_supported(MatrixTransform transform)
{
  switch (canonical_transform_for_scalar<Scalar>(transform))
  {
    case MatrixTransform::normal:
    case MatrixTransform::transpose:
    case MatrixTransform::conjugate_transpose:
      return true;
    case MatrixTransform::conjugate:
      return false;
  }
  PANIC("invalid canonical MatrixTransform", std::to_underlying(transform));
}
 
template <uni20::BlasScalar Scalar> constexpr char blas_trans_char(MatrixTransform transform)
{
  switch (canonical_transform_for_scalar<Scalar>(transform))
  {
    case MatrixTransform::normal:
      return 'N';
    case MatrixTransform::transpose:
      return 'T';
    case MatrixTransform::conjugate:
      return 'R';
    case MatrixTransform::conjugate_transpose:
      return 'C';
  }
  PANIC("invalid canonical MatrixTransform", std::to_underlying(transform));
}
 
template <class Scalar, class Handle = Scalar*> struct BlasWritableMatrix
{
    Handle data{};
    blas_int rows = 0;
    blas_int cols = 0;
    blas_int leading_dimension = 0;
};
 
template <class Scalar, class Handle = Scalar const*> struct BlasReadableMatrix
{
    Handle data{};
    blas_int rows = 0;
    blas_int cols = 0;
    blas_int leading_dimension = 0;
    MatrixTransform transform = MatrixTransform::normal;
};
 
constexpr blas_int transformed_rows(blas_int rows, blas_int cols, MatrixTransform transform)
{
  return swaps_axes(transform) ? cols : rows;
}
 
constexpr blas_int transformed_cols(blas_int rows, blas_int cols, MatrixTransform transform)
{
  return swaps_axes(transform) ? rows : cols;
}
 
} // namespace uni20::linalg::blas