Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector > Struct Template Reference

#include <PlainObjectBase.h>

Static Public Member Functions
static void	run (DenseBase< Derived > &_this, Index rows, Index cols)
static void	run (DenseBase< Derived > &_this, const DenseBase< OtherDerived > &other)

Static Public Attributes
static constexpr bool	IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value

Member Function Documentation

run() [1/2]

template<typename Derived , typename OtherDerived , bool IsVector>

static void Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run ( DenseBase< Derived > &  _this, const DenseBase< OtherDerived > &  other  )

inlinestatic

                                                                                   {
    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
 
    // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
    // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
    // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
    // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
    // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
 
    if (IsRelocatable &&
        ((Derived::IsRowMajor && _this.cols() == other.cols()) ||  // row-major and we change only the number of rows
         (!Derived::IsRowMajor &&
          _this.rows() == other.rows())))  // column-major and we change only the number of columns
    {
      const Index new_rows = other.rows() - _this.rows();
      const Index new_cols = other.cols() - _this.cols();
      _this.derived().m_storage.conservativeResize(other.size(), other.rows(), other.cols());
      if (new_rows > 0)
        _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
      else if (new_cols > 0)
        _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
    } else {
      // The storage order does not allow us to use reallocation.
      Derived tmp(other);
      const Index common_rows = numext::mini(tmp.rows(), _this.rows());
      const Index common_cols = numext::mini(tmp.cols(), _this.cols());
      tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
      _this.derived().swap(tmp);
    }
  }

References Eigen::PlainObjectBase< Derived >::cols(), EIGEN_STATIC_ASSERT_DYNAMIC_SIZE, Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::IsRelocatable, Eigen::numext::mini(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::DenseBase< Derived >::swap(), and tmp.

run() [2/2]

template<typename Derived , typename OtherDerived , bool IsVector>

static void Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run ( DenseBase< Derived > &  _this, Index  rows, Index  cols  )

inlinestatic

                                                                     {
    if (_this.rows() == rows && _this.cols() == cols) return;
    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
 
    if (IsRelocatable &&
        ((Derived::IsRowMajor && _this.cols() == cols) ||  // row-major and we change only the number of rows
         (!Derived::IsRowMajor && _this.rows() == rows)))  // column-major and we change only the number of columns
    {
#ifndef EIGEN_NO_DEBUG
      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime, Derived::MaxRowsAtCompileTime,
                                             Derived::MaxColsAtCompileTime>::run(rows, cols);
#endif
      _this.derived().m_storage.conservativeResize(rows * cols, rows, cols);
    } else {
      // The storage order does not allow us to use reallocation.
      Derived tmp(rows, cols);
      const Index common_rows = numext::mini(rows, _this.rows());
      const Index common_cols = numext::mini(cols, _this.cols());
      tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
      _this.derived().swap(tmp);
    }
  }

References cols, EIGEN_STATIC_ASSERT_DYNAMIC_SIZE, Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::IsRelocatable, Eigen::numext::mini(), rows, Eigen::DenseBase< Derived >::swap(), and tmp.

Referenced by Eigen::PlainObjectBase< Derived >::conservativeResize(), and Eigen::PlainObjectBase< Derived >::conservativeResizeLike().

Member Data Documentation

IsRelocatable

template<typename Derived , typename OtherDerived , bool IsVector>

constexpr bool Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value

staticconstexpr

Referenced by Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run(), and Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, true >::run().

---

The documentation for this struct was generated from the following file:

• PlainObjectBase.h