From df6561a73fcaa11249d7fe62fa661be99c0afd67 Mon Sep 17 00:00:00 2001 From: Gael Guennebaud Date: Wed, 15 Jul 2009 17:00:49 +0200 Subject: change the implementation of BandMatrix to follow the BLAS/LAPACK storage scheme --- Eigen/src/Core/BandMatrix.h | 119 ++++++++++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 55 deletions(-) (limited to 'Eigen/src/Core/BandMatrix.h') diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index 03d17dac2..902b9a826 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -28,28 +28,28 @@ /** \nonstableyet * \class BandMatrix * - * \brief + * \brief * * \param * - * \sa + * \sa */ -template -struct ei_traits > +template +struct ei_traits > { typedef _Scalar Scalar; enum { CoeffReadCost = NumTraits::ReadCost, - RowsAtCompileTime = Size, - ColsAtCompileTime = Size, - MaxRowsAtCompileTime = Size, - MaxColsAtCompileTime = Size, + RowsAtCompileTime = Rows, + ColsAtCompileTime = Cols, + MaxRowsAtCompileTime = Rows, + MaxColsAtCompileTime = Cols, Flags = 0 }; }; -template -class BandMatrix : public MultiplierBase > +template +class BandMatrix : public MultiplierBase > { public: @@ -63,68 +63,80 @@ class BandMatrix : public MultiplierBase }; typedef typename ei_traits::Scalar Scalar; typedef Matrix PlainMatrixType; - + protected: enum { - DataSizeAtCompileTime = ((Size!=Dynamic) && (Supers!=Dynamic) && (Subs!=Dynamic)) - ? Size*(Supers+Subs+1) - (Supers*Supers+Subs*Subs)/2 - : Dynamic + DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) + ? 1 + Supers + Subs + : Dynamic, + SizeAtCompileTime = EIGEN_ENUM_MIN(Rows,Cols) }; - typedef Matrix DataType; - - public: + typedef Matrix DataType; -// inline BandMatrix() { } + public: - inline BandMatrix(int size=Size, int supers=Supers, int subs=Subs) - : m_data(size*(supers+subs+1) - (supers*supers+subs*subs)/2), - m_size(size), m_supers(supers), m_subs(subs) + inline BandMatrix(int rows=Rows, int cols=Cols, int supers=Supers, int subs=Subs) + : m_data(1+supers+subs,cols), + m_rows(rows), m_supers(supers), m_subs(subs) { } - inline int rows() const { return m_size.value(); } - inline int cols() const { return m_size.value(); } + /** \returns the number of columns */ + inline int rows() const { return m_rows.value(); } + /** \returns the number of rows */ + inline int cols() const { return m_data.cols(); } + + /** \returns the number of super diagonals */ inline int supers() const { return m_supers.value(); } - inline int subs() const { return m_subs.value(); } - inline VectorBlock diagonal() - { return VectorBlock(m_data,0,m_size.value()); } + /** \returns the number of sub diagonals */ + inline int subs() const { return m_subs.value(); } - inline const VectorBlock diagonal() const - { return VectorBlock(m_data,0,m_size.value()); } + /** \returns a vector expression of the main diagonal */ + inline Block diagonal() + { return Block(m_data,supers(),0,1,std::min(rows(),cols())); } + + /** \returns a vector expression of the main diagonal (const version) */ + inline const Block diagonal() const + { return Block(m_data,supers(),0,1,std::min(rows(),cols())); } + + template struct DiagonalIntReturnType { + enum { + DiagonalSize = RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic + ? Dynamic + : Index<0 + ? EIGEN_ENUM_MIN(ColsAtCompileTime, RowsAtCompileTime + Index) + : EIGEN_ENUM_MIN(RowsAtCompileTime, ColsAtCompileTime - Index) + }; + typedef Block Type; + }; - template - VectorBlock - diagonal() + /** \returns a vector expression of the \a Index -th sub or super diagonal */ + template inline typename DiagonalIntReturnType::Type diagonal() { - return VectorBlock - (m_data,Index<0 ? subDiagIndex(-Index) : superDiagIndex(Index), m_size.value()-ei_abs(Index)); + return typename DiagonalIntReturnType::Type(m_data, supers()-Index, ei_abs(Index), 1, diagonalLength(Index)); } - template - const VectorBlock - diagonal() const + /** \returns a vector expression of the \a Index -th sub or super diagonal */ + template inline const typename DiagonalIntReturnType::Type diagonal() const { - return VectorBlock - (m_data,Index<0 ? subDiagIndex(-Index) : superDiagIndex(Index), m_size.value()-ei_abs(Index)); + return typename DiagonalIntReturnType::Type(m_data, supers()-Index, ei_abs(Index), 1, diagonalLength(Index)); } - inline VectorBlock diagonal(int index) + /** \returns a vector expression of the \a i -th sub or super diagonal */ + inline Block diagonal(int i) { - ei_assert((index<0 && -index<=subs()) || (index>=0 && index<=supers())); - return VectorBlock(m_data, - index<0 ? subDiagIndex(-index) : superDiagIndex(index), m_size.value()-ei_abs(index)); + ei_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + return Block(m_data, supers()-i, ei_abs(i), 1, diagonalLength(i)); } - const VectorBlock diagonal(int index) const + + /** \returns a vector expression of the \a i -th sub or super diagonal */ + inline const Block diagonal(int i) const { - ei_assert((index<0 && -index<=subs()) || (index>=0 && index<=supers())); - return VectorBlock(m_data, - index<0 ? subDiagIndex(-index) : superDiagIndex(index), m_size.value()-ei_abs(index)); + ei_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + return Block(m_data, supers()-i, ei_abs(i), 1, diagonalLength(i)); } -// inline VectorBlock subDiagonal() -// { return VectorBlock(m_data,0,m_size.value()); } - PlainMatrixType toDense() const { PlainMatrixType res(rows(),cols()); @@ -139,14 +151,11 @@ class BandMatrix : public MultiplierBase protected: - inline int subDiagIndex(int i) const - { return m_size.value()*(m_supers.value()+i)-(ei_abs2(i-1) + ei_abs2(m_supers.value()))/2; } - - inline int superDiagIndex(int i) const - { return m_size.value()*i-ei_abs2(i-1)/2; } + inline int diagonalLength(int i) const + { return i<0 ? std::min(cols(),rows()+i) : std::min(rows(),cols()-i); } DataType m_data; - ei_int_if_dynamic m_size; + ei_int_if_dynamic m_rows; ei_int_if_dynamic m_supers; ei_int_if_dynamic m_subs; }; -- cgit v1.2.3