mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-04-19 16:19:37 +08:00
458 lines
20 KiB
C++
458 lines
20 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
|
|
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
|
|
//
|
|
// Eigen is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// Alternatively, you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation; either version 2 of
|
|
// the License, or (at your option) any later version.
|
|
//
|
|
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License and a copy of the GNU General Public License along with
|
|
// Eigen. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifndef EIGEN_MATRIXBASE_H
|
|
#define EIGEN_MATRIXBASE_H
|
|
|
|
/** \class MatrixBase
|
|
* \ingroup Core_Module
|
|
*
|
|
* \brief Base class for all dense matrices, vectors, and expressions
|
|
*
|
|
* This class is the base that is inherited by all matrix, vector, and related expression
|
|
* types. Most of the Eigen API is contained in this class, and its base classes. Other important
|
|
* classes for the Eigen API are Matrix, and VectorwiseOp.
|
|
*
|
|
* Note that some methods are defined in other modules such as the \ref LU_Module LU module
|
|
* for all functions related to matrix inversions.
|
|
*
|
|
* \param Derived is the derived type, e.g. a matrix type, or an expression, etc.
|
|
*
|
|
* When writing a function taking Eigen objects as argument, if you want your function
|
|
* to take as argument any matrix, vector, or expression, just let it take a
|
|
* MatrixBase argument. As an example, here is a function printFirstRow which, given
|
|
* a matrix, vector, or expression \a x, prints the first row of \a x.
|
|
*
|
|
* \code
|
|
template<typename Derived>
|
|
void printFirstRow(const Eigen::MatrixBase<Derived>& x)
|
|
{
|
|
cout << x.row(0) << endl;
|
|
}
|
|
* \endcode
|
|
*
|
|
* \sa \ref TopicClassHierarchy
|
|
*/
|
|
template<typename Derived> class MatrixBase
|
|
: public DenseBase<Derived>
|
|
{
|
|
public:
|
|
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
|
typedef MatrixBase StorageBaseType;
|
|
typedef typename internal::traits<Derived>::StorageKind StorageKind;
|
|
typedef typename internal::traits<Derived>::Index Index;
|
|
typedef typename internal::traits<Derived>::Scalar Scalar;
|
|
typedef typename internal::packet_traits<Scalar>::type PacketScalar;
|
|
typedef typename NumTraits<Scalar>::Real RealScalar;
|
|
|
|
typedef DenseBase<Derived> Base;
|
|
using Base::RowsAtCompileTime;
|
|
using Base::ColsAtCompileTime;
|
|
using Base::SizeAtCompileTime;
|
|
using Base::MaxRowsAtCompileTime;
|
|
using Base::MaxColsAtCompileTime;
|
|
using Base::MaxSizeAtCompileTime;
|
|
using Base::IsVectorAtCompileTime;
|
|
using Base::Flags;
|
|
using Base::CoeffReadCost;
|
|
|
|
using Base::derived;
|
|
using Base::const_cast_derived;
|
|
using Base::rows;
|
|
using Base::cols;
|
|
using Base::size;
|
|
using Base::coeff;
|
|
using Base::coeffRef;
|
|
using Base::lazyAssign;
|
|
using Base::eval;
|
|
using Base::operator+=;
|
|
using Base::operator-=;
|
|
using Base::operator*=;
|
|
using Base::operator/=;
|
|
|
|
typedef typename Base::CoeffReturnType CoeffReturnType;
|
|
typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
|
|
typedef typename Base::RowXpr RowXpr;
|
|
typedef typename Base::ColXpr ColXpr;
|
|
#endif // not EIGEN_PARSED_BY_DOXYGEN
|
|
|
|
|
|
|
|
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
|
/** type of the equivalent square matrix */
|
|
typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
|
|
EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
|
|
#endif // not EIGEN_PARSED_BY_DOXYGEN
|
|
|
|
/** \returns the size of the main diagonal, which is min(rows(),cols()).
|
|
* \sa rows(), cols(), SizeAtCompileTime. */
|
|
inline Index diagonalSize() const { return std::min(rows(),cols()); }
|
|
|
|
/** \brief The plain matrix type corresponding to this expression.
|
|
*
|
|
* This is not necessarily exactly the return type of eval(). In the case of plain matrices,
|
|
* the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
|
|
* that the return type of eval() is either PlainObject or const PlainObject&.
|
|
*/
|
|
typedef Matrix<typename internal::traits<Derived>::Scalar,
|
|
internal::traits<Derived>::RowsAtCompileTime,
|
|
internal::traits<Derived>::ColsAtCompileTime,
|
|
AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
|
|
internal::traits<Derived>::MaxRowsAtCompileTime,
|
|
internal::traits<Derived>::MaxColsAtCompileTime
|
|
> PlainObject;
|
|
|
|
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
|
/** \internal Represents a matrix with all coefficients equal to one another*/
|
|
typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType;
|
|
/** \internal the return type of MatrixBase::adjoint() */
|
|
typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
|
|
CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
|
|
ConstTransposeReturnType
|
|
>::type AdjointReturnType;
|
|
/** \internal Return type of eigenvalues() */
|
|
typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
|
|
/** \internal the return type of identity */
|
|
typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,Derived> IdentityReturnType;
|
|
/** \internal the return type of unit vectors */
|
|
typedef Block<CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
|
|
internal::traits<Derived>::RowsAtCompileTime,
|
|
internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
|
|
#endif // not EIGEN_PARSED_BY_DOXYGEN
|
|
|
|
#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
|
|
# include "../plugins/CommonCwiseUnaryOps.h"
|
|
# include "../plugins/CommonCwiseBinaryOps.h"
|
|
# include "../plugins/MatrixCwiseUnaryOps.h"
|
|
# include "../plugins/MatrixCwiseBinaryOps.h"
|
|
# ifdef EIGEN_MATRIXBASE_PLUGIN
|
|
# include EIGEN_MATRIXBASE_PLUGIN
|
|
# endif
|
|
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
|
|
|
|
/** Special case of the template operator=, in order to prevent the compiler
|
|
* from generating a default operator= (issue hit with g++ 4.1)
|
|
*/
|
|
Derived& operator=(const MatrixBase& other);
|
|
|
|
// We cannot inherit here via Base::operator= since it is causing
|
|
// trouble with MSVC.
|
|
|
|
template <typename OtherDerived>
|
|
Derived& operator=(const DenseBase<OtherDerived>& other);
|
|
|
|
template <typename OtherDerived>
|
|
Derived& operator=(const EigenBase<OtherDerived>& other);
|
|
|
|
template<typename OtherDerived>
|
|
Derived& operator=(const ReturnByValue<OtherDerived>& other);
|
|
|
|
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
|
template<typename ProductDerived, typename Lhs, typename Rhs>
|
|
Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other);
|
|
#endif // not EIGEN_PARSED_BY_DOXYGEN
|
|
|
|
template<typename OtherDerived>
|
|
Derived& operator+=(const MatrixBase<OtherDerived>& other);
|
|
template<typename OtherDerived>
|
|
Derived& operator-=(const MatrixBase<OtherDerived>& other);
|
|
|
|
template<typename OtherDerived>
|
|
const typename ProductReturnType<Derived,OtherDerived>::Type
|
|
operator*(const MatrixBase<OtherDerived> &other) const;
|
|
|
|
template<typename OtherDerived>
|
|
const typename LazyProductReturnType<Derived,OtherDerived>::Type
|
|
lazyProduct(const MatrixBase<OtherDerived> &other) const;
|
|
|
|
template<typename OtherDerived>
|
|
Derived& operator*=(const EigenBase<OtherDerived>& other);
|
|
|
|
template<typename OtherDerived>
|
|
void applyOnTheLeft(const EigenBase<OtherDerived>& other);
|
|
|
|
template<typename OtherDerived>
|
|
void applyOnTheRight(const EigenBase<OtherDerived>& other);
|
|
|
|
template<typename DiagonalDerived>
|
|
const DiagonalProduct<Derived, DiagonalDerived, OnTheRight>
|
|
operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
|
|
|
|
template<typename OtherDerived>
|
|
Scalar dot(const MatrixBase<OtherDerived>& other) const;
|
|
RealScalar squaredNorm() const;
|
|
RealScalar norm() const;
|
|
RealScalar stableNorm() const;
|
|
RealScalar blueNorm() const;
|
|
RealScalar hypotNorm() const;
|
|
const PlainObject normalized() const;
|
|
void normalize();
|
|
|
|
const AdjointReturnType adjoint() const;
|
|
void adjointInPlace();
|
|
|
|
typedef Diagonal<Derived> DiagonalReturnType;
|
|
DiagonalReturnType diagonal();
|
|
typedef const Diagonal<const Derived> ConstDiagonalReturnType;
|
|
ConstDiagonalReturnType diagonal() const;
|
|
|
|
template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
|
|
template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
|
|
|
|
template<int Index> typename DiagonalIndexReturnType<Index>::Type diagonal();
|
|
template<int Index> typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
|
|
|
|
typename DiagonalIndexReturnType<Dynamic>::Type diagonal(Index index);
|
|
typename ConstDiagonalIndexReturnType<Dynamic>::Type diagonal(Index index) const;
|
|
|
|
template<unsigned int Mode> TriangularView<Derived, Mode> part();
|
|
template<unsigned int Mode> const TriangularView<Derived, Mode> part() const;
|
|
|
|
template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
|
|
template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
|
|
|
|
template<unsigned int Mode> typename TriangularViewReturnType<Mode>::Type triangularView();
|
|
template<unsigned int Mode> typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
|
|
|
|
template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
|
|
template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
|
|
|
|
template<unsigned int UpLo> typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
|
|
template<unsigned int UpLo> typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
|
|
|
|
const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
|
|
typename NumTraits<Scalar>::Real m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
|
|
static const IdentityReturnType Identity();
|
|
static const IdentityReturnType Identity(Index rows, Index cols);
|
|
static const BasisReturnType Unit(Index size, Index i);
|
|
static const BasisReturnType Unit(Index i);
|
|
static const BasisReturnType UnitX();
|
|
static const BasisReturnType UnitY();
|
|
static const BasisReturnType UnitZ();
|
|
static const BasisReturnType UnitW();
|
|
|
|
const DiagonalWrapper<Derived> asDiagonal() const;
|
|
|
|
Derived& setIdentity();
|
|
Derived& setIdentity(Index rows, Index cols);
|
|
|
|
bool isIdentity(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
bool isDiagonal(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
|
|
bool isUpperTriangular(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
bool isLowerTriangular(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
|
|
template<typename OtherDerived>
|
|
bool isOrthogonal(const MatrixBase<OtherDerived>& other,
|
|
RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
bool isUnitary(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
|
|
|
|
/** \returns true if each coefficients of \c *this and \a other are all exactly equal.
|
|
* \warning When using floating point scalar values you probably should rather use a
|
|
* fuzzy comparison such as isApprox()
|
|
* \sa isApprox(), operator!= */
|
|
template<typename OtherDerived>
|
|
inline bool operator==(const MatrixBase<OtherDerived>& other) const
|
|
{ return cwiseEqual(other).all(); }
|
|
|
|
/** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
|
|
* \warning When using floating point scalar values you probably should rather use a
|
|
* fuzzy comparison such as isApprox()
|
|
* \sa isApprox(), operator== */
|
|
template<typename OtherDerived>
|
|
inline bool operator!=(const MatrixBase<OtherDerived>& other) const
|
|
{ return cwiseNotEqual(other).any(); }
|
|
|
|
NoAlias<Derived,Eigen::MatrixBase > noalias();
|
|
|
|
inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
|
|
inline ForceAlignedAccess<Derived> forceAlignedAccess();
|
|
template<bool Enable> inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type forceAlignedAccessIf() const;
|
|
template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
|
|
|
|
Scalar trace() const;
|
|
|
|
/////////// Array module ///////////
|
|
|
|
template<int p> RealScalar lpNorm() const;
|
|
|
|
MatrixBase<Derived>& matrix() { return *this; }
|
|
const MatrixBase<Derived>& matrix() const { return *this; }
|
|
|
|
/** \returns an \link ArrayBase Array \endlink expression of this matrix
|
|
* \sa ArrayBase::matrix() */
|
|
ArrayWrapper<Derived> array() { return derived(); }
|
|
const ArrayWrapper<Derived> array() const { return derived(); }
|
|
|
|
/////////// LU module ///////////
|
|
|
|
const FullPivLU<PlainObject> fullPivLu() const;
|
|
const PartialPivLU<PlainObject> partialPivLu() const;
|
|
const PartialPivLU<PlainObject> lu() const;
|
|
const internal::inverse_impl<Derived> inverse() const;
|
|
template<typename ResultType>
|
|
void computeInverseAndDetWithCheck(
|
|
ResultType& inverse,
|
|
typename ResultType::Scalar& determinant,
|
|
bool& invertible,
|
|
const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
|
|
) const;
|
|
template<typename ResultType>
|
|
void computeInverseWithCheck(
|
|
ResultType& inverse,
|
|
bool& invertible,
|
|
const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
|
|
) const;
|
|
Scalar determinant() const;
|
|
|
|
/////////// Cholesky module ///////////
|
|
|
|
const LLT<PlainObject> llt() const;
|
|
const LDLT<PlainObject> ldlt() const;
|
|
|
|
/////////// QR module ///////////
|
|
|
|
const HouseholderQR<PlainObject> householderQr() const;
|
|
const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
|
|
const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
|
|
|
|
EigenvaluesReturnType eigenvalues() const;
|
|
RealScalar operatorNorm() const;
|
|
|
|
/////////// SVD module ///////////
|
|
|
|
JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
|
|
|
|
/////////// Geometry module ///////////
|
|
|
|
template<typename OtherDerived>
|
|
PlainObject cross(const MatrixBase<OtherDerived>& other) const;
|
|
template<typename OtherDerived>
|
|
PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
|
|
PlainObject unitOrthogonal(void) const;
|
|
Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
|
|
ScalarMultipleReturnType operator*(const UniformScaling<Scalar>& s) const;
|
|
enum {
|
|
SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
|
|
};
|
|
typedef Block<const Derived,
|
|
internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
|
|
internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
|
|
typedef CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>,
|
|
ConstStartMinusOne > HNormalizedReturnType;
|
|
|
|
const HNormalizedReturnType hnormalized() const;
|
|
|
|
// put this as separate enum value to work around possible GCC 4.3 bug (?)
|
|
enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1?Vertical:Horizontal };
|
|
typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
|
|
|
|
HomogeneousReturnType homogeneous() const;
|
|
|
|
////////// Householder module ///////////
|
|
|
|
void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
|
|
template<typename EssentialPart>
|
|
void makeHouseholder(EssentialPart& essential,
|
|
Scalar& tau, RealScalar& beta) const;
|
|
template<typename EssentialPart>
|
|
void applyHouseholderOnTheLeft(const EssentialPart& essential,
|
|
const Scalar& tau,
|
|
Scalar* workspace);
|
|
template<typename EssentialPart>
|
|
void applyHouseholderOnTheRight(const EssentialPart& essential,
|
|
const Scalar& tau,
|
|
Scalar* workspace);
|
|
|
|
///////// Jacobi module /////////
|
|
|
|
template<typename OtherScalar>
|
|
void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
|
|
template<typename OtherScalar>
|
|
void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
|
|
|
|
///////// MatrixFunctions module /////////
|
|
|
|
typedef typename internal::stem_function<Scalar>::type StemFunction;
|
|
const MatrixExponentialReturnValue<Derived> exp() const;
|
|
const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
|
|
const MatrixFunctionReturnValue<Derived> cosh() const;
|
|
const MatrixFunctionReturnValue<Derived> sinh() const;
|
|
const MatrixFunctionReturnValue<Derived> cos() const;
|
|
const MatrixFunctionReturnValue<Derived> sin() const;
|
|
|
|
#ifdef EIGEN2_SUPPORT
|
|
template<typename ProductDerived, typename Lhs, typename Rhs>
|
|
Derived& operator+=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
|
|
EvalBeforeAssigningBit>& other);
|
|
|
|
template<typename ProductDerived, typename Lhs, typename Rhs>
|
|
Derived& operator-=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
|
|
EvalBeforeAssigningBit>& other);
|
|
|
|
/** \deprecated because .lazy() is deprecated
|
|
* Overloaded for cache friendly product evaluation */
|
|
template<typename OtherDerived>
|
|
Derived& lazyAssign(const Flagged<OtherDerived, 0, EvalBeforeAssigningBit>& other)
|
|
{ return lazyAssign(other._expression()); }
|
|
|
|
template<unsigned int Added>
|
|
const Flagged<Derived, Added, 0> marked() const;
|
|
const Flagged<Derived, 0, EvalBeforeAssigningBit> lazy() const;
|
|
|
|
inline const Cwise<Derived> cwise() const;
|
|
inline Cwise<Derived> cwise();
|
|
|
|
VectorBlock<Derived> start(Index size);
|
|
const VectorBlock<Derived> start(Index size) const;
|
|
VectorBlock<Derived> end(Index size);
|
|
const VectorBlock<Derived> end(Index size) const;
|
|
template<int Size> VectorBlock<Derived,Size> start();
|
|
template<int Size> const VectorBlock<Derived,Size> start() const;
|
|
template<int Size> VectorBlock<Derived,Size> end();
|
|
template<int Size> const VectorBlock<Derived,Size> end() const;
|
|
|
|
Minor<Derived> minor(Index row, Index col);
|
|
const Minor<Derived> minor(Index row, Index col) const;
|
|
#endif
|
|
|
|
protected:
|
|
MatrixBase() : Base() {}
|
|
|
|
private:
|
|
explicit MatrixBase(int);
|
|
MatrixBase(int,int);
|
|
template<typename OtherDerived> explicit MatrixBase(const MatrixBase<OtherDerived>&);
|
|
protected:
|
|
// mixing arrays and matrices is not legal
|
|
template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& array)
|
|
{EIGEN_STATIC_ASSERT(sizeof(typename OtherDerived::Scalar)==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES);}
|
|
// mixing arrays and matrices is not legal
|
|
template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& array)
|
|
{EIGEN_STATIC_ASSERT(sizeof(typename OtherDerived::Scalar)==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES);}
|
|
};
|
|
|
|
#endif // EIGEN_MATRIXBASE_H
|