EigenBase.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// SPDX-License-Identifier: MPL-2.0
 
#ifndef EIGEN_EIGENBASE_H
#define EIGEN_EIGENBASE_H
 
// IWYU pragma: private
#include "./InternalHeaderCheck.h"
 
namespace Eigen {

template <typename Derived>
struct EigenBase {
  //   typedef typename internal::plain_matrix_type<Derived>::type PlainObject;

  using Index = Eigen::Index;
 
  // FIXME is it needed?
  using StorageKind = typename internal::traits<Derived>::StorageKind;

  EIGEN_DEVICE_FUNC constexpr Derived& derived() { return *static_cast<Derived*>(this); }
  EIGEN_DEVICE_FUNC constexpr const Derived& derived() const { return *static_cast<const Derived*>(this); }
 
  EIGEN_DEVICE_FUNC inline constexpr Derived& const_cast_derived() const {
    return *static_cast<Derived*>(const_cast<EigenBase*>(this));
  }
  EIGEN_DEVICE_FUNC constexpr inline const Derived& const_derived() const { return *static_cast<const Derived*>(this); }

  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return derived().rows(); }
  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return derived().cols(); }
  EIGEN_DEVICE_FUNC constexpr Index size() const noexcept { return rows() * cols(); }

  template <typename Dest>
  EIGEN_DEVICE_FUNC constexpr inline void evalTo(Dest& dst) const {
    derived().evalTo(dst);
  }

  template <typename Dest>
  EIGEN_DEVICE_FUNC constexpr inline void addTo(Dest& dst) const {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    typename Dest::PlainObject res(rows(), cols());
    evalTo(res);
    dst += res;
  }

  template <typename Dest>
  EIGEN_DEVICE_FUNC constexpr inline void subTo(Dest& dst) const {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    typename Dest::PlainObject res(rows(), cols());
    evalTo(res);
    dst -= res;
  }

  template <typename Dest>
  EIGEN_DEVICE_FUNC constexpr inline void applyThisOnTheRight(Dest& dst) const {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    dst = dst * this->derived();
  }

  template <typename Dest>
  EIGEN_DEVICE_FUNC constexpr inline void applyThisOnTheLeft(Dest& dst) const {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    dst = this->derived() * dst;
  }
 
  template <typename Device>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper<Derived, Device> device(Device& device);
  template <typename Device>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper<const Derived, Device> device(Device& device) const;
};
 
/***************************************************************************
 * Implementation of matrix base methods
 ***************************************************************************/

template <typename Derived>
template <typename OtherDerived>
EIGEN_DEVICE_FUNC constexpr Derived& DenseBase<Derived>::operator=(const EigenBase<OtherDerived>& other) {
  call_assignment(derived(), other.derived());
  return derived();
}
 
template <typename Derived>
template <typename OtherDerived>
EIGEN_DEVICE_FUNC constexpr Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived>& other) {
  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar, typename OtherDerived::Scalar>());
  return derived();
}
 
template <typename Derived>
template <typename OtherDerived>
EIGEN_DEVICE_FUNC constexpr Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived>& other) {
  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar, typename OtherDerived::Scalar>());
  return derived();
}
 
}  // end namespace Eigen
 
#endif  // EIGEN_EIGENBASE_H