VariableBlock.hpp

Go to the documentation of this file.

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <concepts>
#include <type_traits>
#include <utility>
 
#include <Eigen/Core>
 
#include "sleipnir/autodiff/Slice.hpp"
#include "sleipnir/autodiff/Variable.hpp"
#include "sleipnir/util/Assert.hpp"
#include "sleipnir/util/FunctionRef.hpp"
 
namespace sleipnir {
 
template <typename Mat>
class VariableBlock {
 public:
  VariableBlock(const VariableBlock<Mat>& values) = default;
 
  VariableBlock<Mat>& operator=(const VariableBlock<Mat>& values) {
    if (this == &values) {
      return *this;
    }
 
    if (m_mat == nullptr) {
      m_mat = values.m_mat;
      m_rowSlice = values.m_rowSlice;
      m_rowSliceLength = values.m_rowSliceLength;
      m_colSlice = values.m_colSlice;
      m_colSliceLength = values.m_colSliceLength;
    } else {
      Assert(Rows() == values.Rows());
      Assert(Cols() == values.Cols());
 
      for (int row = 0; row < Rows(); ++row) {
        for (int col = 0; col < Cols(); ++col) {
          (*this)(row, col) = values(row, col);
        }
      }
    }
 
    return *this;
  }
 
  VariableBlock(VariableBlock<Mat>&&) = default;
 
  VariableBlock<Mat>& operator=(VariableBlock<Mat>&& values) {
    if (this == &values) {
      return *this;
    }
 
    if (m_mat == nullptr) {
      m_mat = values.m_mat;
      m_rowSlice = values.m_rowSlice;
      m_rowSliceLength = values.m_rowSliceLength;
      m_colSlice = values.m_colSlice;
      m_colSliceLength = values.m_colSliceLength;
    } else {
      Assert(Rows() == values.Rows());
      Assert(Cols() == values.Cols());
 
      for (int row = 0; row < Rows(); ++row) {
        for (int col = 0; col < Cols(); ++col) {
          (*this)(row, col) = values(row, col);
        }
      }
    }
 
    return *this;
  }
 
  VariableBlock(Mat& mat)  // NOLINT
      : m_mat{&mat},
        m_rowSlice{0, mat.Rows(), 1},
        m_rowSliceLength{m_rowSlice.Adjust(mat.Rows())},
        m_colSlice{0, mat.Cols(), 1},
        m_colSliceLength{m_colSlice.Adjust(mat.Cols())} {}
 
  VariableBlock(Mat& mat, int rowOffset, int colOffset, int blockRows,
                int blockCols)
      : m_mat{&mat},
        m_rowSlice{rowOffset, rowOffset + blockRows, 1},
        m_rowSliceLength{m_rowSlice.Adjust(mat.Rows())},
        m_colSlice{colOffset, colOffset + blockCols, 1},
        m_colSliceLength{m_colSlice.Adjust(mat.Cols())} {}
 
  VariableBlock(Mat& mat, Slice rowSlice, int rowSliceLength, Slice colSlice,
                int colSliceLength)
      : m_mat{&mat},
        m_rowSlice{std::move(rowSlice)},
        m_rowSliceLength{rowSliceLength},
        m_colSlice{std::move(colSlice)},
        m_colSliceLength{colSliceLength} {}
 
  VariableBlock<Mat>& operator=(double value) {
    Assert(Rows() == 1 && Cols() == 1);
 
    (*this)(0, 0) = value;
 
    return *this;
  }
 
  void SetValue(double value) {
    Assert(Rows() == 1 && Cols() == 1);
 
    (*this)(0, 0).SetValue(value);
  }
 
  template <typename Derived>
  VariableBlock<Mat>& operator=(const Eigen::MatrixBase<Derived>& values) {
    Assert(Rows() == values.rows());
    Assert(Cols() == values.cols());
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) = values(row, col);
      }
    }
 
    return *this;
  }
 
  template <typename Derived>
    requires std::same_as<typename Derived::Scalar, double>
  void SetValue(const Eigen::MatrixBase<Derived>& values) {
    Assert(Rows() == values.rows());
    Assert(Cols() == values.cols());
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col).SetValue(values(row, col));
      }
    }
  }
 
  VariableBlock<Mat>& operator=(const Mat& values) {
    Assert(Rows() == values.Rows());
    Assert(Cols() == values.Cols());
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) = values(row, col);
      }
    }
    return *this;
  }
 
  VariableBlock<Mat>& operator=(Mat&& values) {
    Assert(Rows() == values.Rows());
    Assert(Cols() == values.Cols());
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) = std::move(values(row, col));
      }
    }
    return *this;
  }
 
  Variable& operator()(int row, int col)
    requires(!std::is_const_v<Mat>)
  {
    Assert(row >= 0 && row < Rows());
    Assert(col >= 0 && col < Cols());
    return (*m_mat)(m_rowSlice.start + row * m_rowSlice.step,
                    m_colSlice.start + col * m_colSlice.step);
  }
 
  const Variable& operator()(int row, int col) const {
    Assert(row >= 0 && row < Rows());
    Assert(col >= 0 && col < Cols());
    return (*m_mat)(m_rowSlice.start + row * m_rowSlice.step,
                    m_colSlice.start + col * m_colSlice.step);
  }
 
  Variable& operator()(int row)
    requires(!std::is_const_v<Mat>)
  {
    Assert(row >= 0 && row < Rows() * Cols());
    return (*this)(row / Cols(), row % Cols());
  }
 
  const Variable& operator()(int row) const {
    Assert(row >= 0 && row < Rows() * Cols());
    return (*this)(row / Cols(), row % Cols());
  }
 
  VariableBlock<Mat> Block(int rowOffset, int colOffset, int blockRows,
                           int blockCols) {
    Assert(rowOffset >= 0 && rowOffset <= Rows());
    Assert(colOffset >= 0 && colOffset <= Cols());
    Assert(blockRows >= 0 && blockRows <= Rows() - rowOffset);
    Assert(blockCols >= 0 && blockCols <= Cols() - colOffset);
    return (*this)({rowOffset, rowOffset + blockRows, 1},
                   {colOffset, colOffset + blockCols, 1});
  }
 
  const VariableBlock<const Mat> Block(int rowOffset, int colOffset,
                                       int blockRows, int blockCols) const {
    Assert(rowOffset >= 0 && rowOffset <= Rows());
    Assert(colOffset >= 0 && colOffset <= Cols());
    Assert(blockRows >= 0 && blockRows <= Rows() - rowOffset);
    Assert(blockCols >= 0 && blockCols <= Cols() - colOffset);
    return (*this)({rowOffset, rowOffset + blockRows, 1},
                   {colOffset, colOffset + blockCols, 1});
  }
 
  VariableBlock<Mat> operator()(Slice rowSlice, Slice colSlice) {
    int rowSliceLength = rowSlice.Adjust(m_rowSliceLength);
    int colSliceLength = colSlice.Adjust(m_colSliceLength);
    return VariableBlock{
        *m_mat,
        {m_rowSlice.start + rowSlice.start * m_rowSlice.step,
         m_rowSlice.start + rowSlice.stop, m_rowSlice.step * rowSlice.step},
        rowSliceLength,
        {m_colSlice.start + colSlice.start * m_colSlice.step,
         m_colSlice.start + colSlice.stop, m_colSlice.step * colSlice.step},
        colSliceLength};
  }
 
  const VariableBlock<const Mat> operator()(Slice rowSlice,
                                            Slice colSlice) const {
    int rowSliceLength = rowSlice.Adjust(m_rowSliceLength);
    int colSliceLength = colSlice.Adjust(m_colSliceLength);
    return VariableBlock{
        *m_mat,
        {m_rowSlice.start + rowSlice.start * m_rowSlice.step,
         m_rowSlice.start + rowSlice.stop, m_rowSlice.step * rowSlice.step},
        rowSliceLength,
        {m_colSlice.start + colSlice.start * m_colSlice.step,
         m_colSlice.start + colSlice.stop, m_colSlice.step * colSlice.step},
        colSliceLength};
  }
 
  VariableBlock<Mat> operator()(Slice rowSlice, int rowSliceLength,
                                Slice colSlice, int colSliceLength) {
    return VariableBlock{
        *m_mat,
        {m_rowSlice.start + rowSlice.start * m_rowSlice.step,
         m_rowSlice.start + rowSlice.stop, m_rowSlice.step * rowSlice.step},
        rowSliceLength,
        {m_colSlice.start + colSlice.start * m_colSlice.step,
         m_colSlice.start + colSlice.stop, m_colSlice.step * colSlice.step},
        colSliceLength};
  }
 
  const VariableBlock<const Mat> operator()(Slice rowSlice, int rowSliceLength,
                                            Slice colSlice,
                                            int colSliceLength) const {
    return VariableBlock{
        *m_mat,
        {m_rowSlice.start + rowSlice.start * m_rowSlice.step,
         m_rowSlice.start + rowSlice.stop, m_rowSlice.step * rowSlice.step},
        rowSliceLength,
        {m_colSlice.start + colSlice.start * m_colSlice.step,
         m_colSlice.start + colSlice.stop, m_colSlice.step * colSlice.step},
        colSliceLength};
  }
 
  VariableBlock<Mat> Segment(int offset, int length) {
    Assert(offset >= 0 && offset < Rows() * Cols());
    Assert(length >= 0 && length <= Rows() * Cols() - offset);
    return Block(offset, 0, length, 1);
  }
 
  const VariableBlock<Mat> Segment(int offset, int length) const {
    Assert(offset >= 0 && offset < Rows() * Cols());
    Assert(length >= 0 && length <= Rows() * Cols() - offset);
    return Block(offset, 0, length, 1);
  }
 
  VariableBlock<Mat> Row(int row) {
    Assert(row >= 0 && row < Rows());
    return Block(row, 0, 1, Cols());
  }
 
  VariableBlock<const Mat> Row(int row) const {
    Assert(row >= 0 && row < Rows());
    return Block(row, 0, 1, Cols());
  }
 
  VariableBlock<Mat> Col(int col) {
    Assert(col >= 0 && col < Cols());
    return Block(0, col, Rows(), 1);
  }
 
  VariableBlock<const Mat> Col(int col) const {
    Assert(col >= 0 && col < Cols());
    return Block(0, col, Rows(), 1);
  }
 
  VariableBlock<Mat>& operator*=(const VariableBlock<Mat>& rhs) {
    Assert(Cols() == rhs.Rows() && Cols() == rhs.Cols());
 
    for (int i = 0; i < Rows(); ++i) {
      for (int j = 0; j < rhs.Cols(); ++j) {
        Variable sum;
        for (int k = 0; k < Cols(); ++k) {
          sum += (*this)(i, k) * rhs(k, j);
        }
        (*this)(i, j) = sum;
      }
    }
 
    return *this;
  }
 
  VariableBlock& operator*=(double rhs) {
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) *= rhs;
      }
    }
 
    return *this;
  }
 
  VariableBlock<Mat>& operator/=(const VariableBlock<Mat>& rhs) {
    Assert(rhs.Rows() == 1 && rhs.Cols() == 1);
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) /= rhs(0, 0);
      }
    }
 
    return *this;
  }
 
  VariableBlock<Mat>& operator/=(double rhs) {
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) /= rhs;
      }
    }
 
    return *this;
  }
 
  VariableBlock<Mat>& operator+=(const VariableBlock<Mat>& rhs) {
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) += rhs(row, col);
      }
    }
 
    return *this;
  }
 
  VariableBlock<Mat>& operator-=(const VariableBlock<Mat>& rhs) {
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        (*this)(row, col) -= rhs(row, col);
      }
    }
 
    return *this;
  }
 
  std::remove_cv_t<Mat> T() const {
    std::remove_cv_t<Mat> result{Cols(), Rows()};
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        result(col, row) = (*this)(row, col);
      }
    }
 
    return result;
  }
 
  int Rows() const { return m_rowSliceLength; }
 
  int Cols() const { return m_colSliceLength; }
 
  double Value(int row, int col) {
    Assert(row >= 0 && row < Rows());
    Assert(col >= 0 && col < Cols());
    return (*m_mat)(m_rowSlice.start + row * m_rowSlice.step,
                    m_colSlice.start + col * m_colSlice.step)
        .Value();
  }
 
  double Value(int index) {
    Assert(index >= 0 && index < Rows() * Cols());
    return Value(index / Cols(), index % Cols());
  }
 
  Eigen::MatrixXd Value() {
    Eigen::MatrixXd result{Rows(), Cols()};
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        result(row, col) = Value(row, col);
      }
    }
 
    return result;
  }
 
  std::remove_cv_t<Mat> CwiseTransform(
      function_ref<Variable(const Variable& x)> unaryOp) const {
    std::remove_cv_t<Mat> result{Rows(), Cols()};
 
    for (int row = 0; row < Rows(); ++row) {
      for (int col = 0; col < Cols(); ++col) {
        result(row, col) = unaryOp((*this)(row, col));
      }
    }
 
    return result;
  }
 
  class iterator {
   public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = Variable;
    using difference_type = std::ptrdiff_t;
    using pointer = Variable*;
    using reference = Variable&;
 
    iterator(VariableBlock<Mat>* mat, int index) : m_mat{mat}, m_index{index} {}
 
    iterator& operator++() {
      ++m_index;
      return *this;
    }
    iterator operator++(int) {
      iterator retval = *this;
      ++(*this);
      return retval;
    }
    bool operator==(const iterator&) const = default;
    reference operator*() { return (*m_mat)(m_index); }
 
   private:
    VariableBlock<Mat>* m_mat;
    int m_index;
  };
 
  class const_iterator {
   public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = Variable;
    using difference_type = std::ptrdiff_t;
    using pointer = Variable*;
    using const_reference = const Variable&;
 
    const_iterator(const VariableBlock<Mat>* mat, int index)
        : m_mat{mat}, m_index{index} {}
 
    const_iterator& operator++() {
      ++m_index;
      return *this;
    }
    const_iterator operator++(int) {
      const_iterator retval = *this;
      ++(*this);
      return retval;
    }
    bool operator==(const const_iterator&) const = default;
    const_reference operator*() const { return (*m_mat)(m_index); }
 
   private:
    const VariableBlock<Mat>* m_mat;
    int m_index;
  };
 
  iterator begin() { return iterator(this, 0); }
 
  iterator end() { return iterator(this, Rows() * Cols()); }
 
  const_iterator begin() const { return const_iterator(this, 0); }
 
  const_iterator end() const { return const_iterator(this, Rows() * Cols()); }
 
  const_iterator cbegin() const { return const_iterator(this, 0); }
 
  const_iterator cend() const { return const_iterator(this, Rows() * Cols()); }
 
  size_t size() const { return Rows() * Cols(); }
 
 private:
  Mat* m_mat = nullptr;
 
  Slice m_rowSlice;
  int m_rowSliceLength = 0;
 
  Slice m_colSlice;
  int m_colSliceLength = 0;
};
 
}  // namespace sleipnir