rotgen/include/rotgen/block.hpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once

#include <rotgen/impl/block.hpp>
#include <rotgen/matrix.hpp>
#include <initializer_list>
#include <cassert>

namespace rotgen
{
  template<typename Ref, int Rows = Dynamic, int Cols = Dynamic, bool Inner = false, int ForceStorageOrder = -1>
  class block : public find_block<Ref>
  {
    using parent        = find_block<Ref>;
    public:
    using scalar_type                   = typename Ref::scalar_type;
    static constexpr int storage_order = (ForceStorageOrder == -1) ? Ref::storage_order : ForceStorageOrder;
    using concrete_type                 = matrix<scalar_type,Rows,Cols,storage_order>;

    static constexpr int RowsAtCompileTime = Rows;
    static constexpr int ColsAtCompileTime = Cols;

    block(Ref& r, std::size_t i0, std::size_t j0, std::size_t ni, std::size_t nj) : parent(r,i0,j0,ni,nj)
    {}

    block(Ref& r, std::size_t i0, std::size_t j0) requires(Rows != -1 && Cols != -1)
    : parent(r,i0,j0,Rows,Cols)
    {}

    block(parent const& base) : parent(base) {}

/*
block transpose() const
{
  return block(static_cast<parent const&>(*this).transpose());
}

block conjugate() const
{
  return block(static_cast<parent const&>(*this).conjugate());
}

block adjoint() const
{
  return block(static_cast<parent const&>(*this).adjoint());
}
*/

  friend bool operator==(block const& lhs, block const& rhs)
  {
    return static_cast<parent const&>(lhs) == static_cast<parent const&>(rhs);
  }

  block& operator+=(block const& rhs)
  {
    static_cast<parent&>(*this) += static_cast<parent const&>(rhs);
    return *this;
  }

  block& operator-=(block const& rhs)
  {
    static_cast<parent&>(*this) -= static_cast<parent const&>(rhs);
    return *this;
  }

  concrete_type operator-() const
  {
    return concrete_type(static_cast<parent const&>(*this).operator-());
  }

  block& operator*=(block const& rhs)
  {
    static_cast<parent&>(*this) *= static_cast<parent const&>(rhs);
    return *this;
  }

  block& operator*=(scalar_type rhs)
  {
    static_cast<parent&>(*this) *= rhs;
    return *this;
  }

  block& operator/=(scalar_type rhs)
  {
    static_cast<parent&>(*this) /= rhs;
    return *this;
  }

  static concrete_type Zero()
  requires (Rows != -1 && Cols != -1)
  {
    return parent::Zero(Rows, Cols);
  }

  static concrete_type Zero(int rows, int cols)
  {
    if constexpr(Rows != -1) assert(rows == Rows &&  "Mismatched between dynamic and static row size");
    if constexpr(Cols != -1) assert(cols == Cols &&  "Mismatched between dynamic and static column size");
    return parent::Zero(rows, cols);
  }

  static concrete_type Constant(scalar_type value)
  requires (Rows != -1 && Cols != -1)
  {
    return parent::Constant(Rows, Cols, static_cast<double>(value));
  }

  static concrete_type Constant(int rows, int cols, scalar_type value)
  {
    if constexpr(Rows != -1) assert(rows == Rows &&  "Mismatched between dynamic and static row size");
    if constexpr(Cols != -1) assert(cols == Cols &&  "Mismatched between dynamic and static column size");
    return parent::Constant(rows, cols, static_cast<double>(value));
  }

  static concrete_type Random()
  requires (Rows != -1 && Cols != -1)
  {
    return parent::Random(Rows, Cols);
  }

  static concrete_type Random(int rows, int cols)
  {
    if constexpr(Rows != -1) assert(rows == Rows &&  "Mismatched between dynamic and static row size");
    if constexpr(Cols != -1) assert(cols == Cols &&  "Mismatched between dynamic and static column size");
    return parent::Random(rows, cols);
  }

  static concrete_type Identity()
  requires (Rows != -1 && Cols != -1)
  {
    return parent::Identity(Rows, Cols);
  }

  static concrete_type Identity(int rows, int cols)
  {
    if constexpr(Rows != -1) assert(rows == Rows &&  "Mismatched between dynamic and static row size");
    if constexpr(Cols != -1) assert(cols == Cols &&  "Mismatched between dynamic and static column size");
    return parent::Identity(rows, cols);
  }

  template<int P>
  double lpNorm() const
  {
    assert(P == 1 || P == 2 || P == Infinity);
    return parent::lpNorm(P);
  }
};

/*
template<typename S, int R, int C, int O, int MR, int MC>
block<S,R,C,O,MR,MC> operator+(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
{
  block<S,R,C,O,MR,MC> that(lhs);
  return that += rhs;
}

template<typename S, int R, int C, int O, int MR, int MC>
block<S,R,C,O,MR,MC> operator-(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
{
  block<S,R,C,O,MR,MC> that(lhs);
  return that -= rhs;
}

template<typename S, int R, int C, int O, int MR, int MC>
block<S,R,C,O,MR,MC> operator*(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
{
  block<S,R,C,O,MR,MC> that(lhs);
    return that *= rhs;
  }

  template<typename S, int R, int C, int O, int MR, int MC>
  block<S,R,C,O,MR,MC> operator*(block<S,R,C,O,MR,MC> const& lhs, double rhs)
  {
    block<S,R,C,O,MR,MC> that(lhs);
    return that *= rhs;
  }

  template<typename S, int R, int C, int O, int MR, int MC>
  block<S,R,C,O,MR,MC> operator*(double lhs, block<S,R,C,O,MR,MC> const&  rhs)
  {
    return rhs * lhs;
  }

  template<typename S, int R, int C, int O, int MR, int MC>
  block<S,R,C,O,MR,MC> operator/(block<S,R,C,O,MR,MC> const& lhs, double rhs)
  {
    block<S,R,C,O,MR,MC> that(lhs);
    return that /= rhs;
  }
*/
}