eigen_matrixbase_addons.h

Go to the documentation of this file.

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program is free software; 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.                                       *
*                                                                           *
* This program 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 General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/

#ifdef __GNUC__
#warning You are including deprecated math stuff
#endif

typedef Scalar ScalarType;

EIGEN_DEPRECATED inline unsigned int ColumnsNumber() const { return cols(); };


EIGEN_DEPRECATED inline unsigned int RowsNumber() const { return rows(); };

EIGEN_DEPRECATED inline Scalar ElementAt(unsigned int i, unsigned int j) const { return (*this)(i,j); };
EIGEN_DEPRECATED inline Scalar& ElementAt(unsigned int i, unsigned int j) { return (*this)(i,j); };
EIGEN_DEPRECATED inline Scalar V(int i) const { return (*this)[i]; };
EIGEN_DEPRECATED inline Scalar& V(int i) { return (*this)[i]; };

EIGEN_DEPRECATED Scalar Determinant() const { return determinant(); };

EIGEN_DEPRECATED Scalar Cofactor(unsigned int i, unsigned int j) const
{
        assert(rows() == cols());
        assert(rows()>2);
        return (((i+j)%2==0) ? 1. : -1.) * minor(i,j).determinant();
};

EIGEN_DEPRECATED ColXpr GetColumn(const unsigned int j) { return col(j); };

EIGEN_DEPRECATED RowXpr GetRow(const unsigned int i) { return row(i); };

EIGEN_DEPRECATED void SwapColumns(const unsigned int i, const unsigned int j)
{
        if (i==j) return;
        col(i).swap(col(j));
};

EIGEN_DEPRECATED void SwapRows(const unsigned int i, const unsigned int j)
{
        if (i==j) return;
        row(i).swap(row(j));
};

EIGEN_DEPRECATED Derived& operator+=(const Scalar k)
{
        cwise() += k;
        return *this;
};

EIGEN_DEPRECATED Derived& operator-=(const Scalar k)
{
        cwise() -= k;
        return *this;
};

// template <int N,int M>
// EIGEN_DEPRECATED void DotProduct(Point<N,Scalar> &m,Point<M,Scalar> &result)
// {
//      unsigned int i, j;
//      for (i=0; i<M; i++)
//      { result[i]=0;
//              for (j=0; j<N; j++)
//                      result[i]+=(*this)[i][j]*m[j];
//      }
// };


template <typename OtherDerived1, typename OtherDerived2>
EIGEN_DEPRECATED void OuterProduct(const MatrixBase<OtherDerived1>& a, const MatrixBase<OtherDerived2>& b)
{ *this = a * b.adjoint(); }

typedef CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived> ScalarAddReturnType;

EIGEN_DEPRECATED const ScalarAddReturnType operator+(const Scalar k) { return cwise() + k; }

EIGEN_DEPRECATED const ScalarAddReturnType operator-(const Scalar k) { return cwise() - k; }

EIGEN_DEPRECATED void SetZero() { setZero(); };

EIGEN_DEPRECATED void SetIdentity() { setIdentity(); };

EIGEN_DEPRECATED void SetColumn(unsigned int j, Scalar* v)
{ col(j) = Map<Matrix<Scalar,RowsAtCompileTime,1> >(v,cols(),1); };

template<typename OtherDerived>
EIGEN_DEPRECATED void SetColumn(unsigned int j, const MatrixBase<OtherDerived>& other)
{ col(j) = other; };

EIGEN_DEPRECATED void SetRow(unsigned int i, Scalar* v)
{ row(i) = Map<Matrix<Scalar,1,ColsAtCompileTime> >(v,1,rows()); };

template<typename OtherDerived>
EIGEN_DEPRECATED void SetRow(unsigned int j, const MatrixBase<OtherDerived>& other)
{ row(j) = other; };

EIGEN_DEPRECATED void SetDiagonal(Scalar *v)
{
        assert(rows() == cols());
        diagonal() = Map<Matrix<Scalar,RowsAtCompileTime,1> >(v,cols(),1);
}

EIGEN_DEPRECATED Scalar Trace() const { return trace(); }

EIGEN_DEPRECATED void Dump()
{
        unsigned int i, j;
        for (i=0; i<rows(); ++i)
        {
                printf("[\t");
                for (j=0; j<cols(); j++)
                        printf("%f\t", coeff(i,j));
                printf("]\n");
        }
        printf("\n");
}

EIGEN_DEPRECATED inline Scalar Norm() const { return norm(); };
EIGEN_DEPRECATED inline Scalar SquaredNorm() const { return squaredNorm(); };
EIGEN_DEPRECATED inline Derived& Normalize() { normalize(); return derived(); };
EIGEN_DEPRECATED inline const PlainMatrixType Normalize() const { return normalized(); };

EIGEN_DEPRECATED inline Derived& Transpose() { transposeInPlace(); return derived(); };
EIGEN_DEPRECATED inline const Eigen::Transpose<Derived> Transpose() const { return transpose(); };

EIGEN_DEPRECATED inline PlainMatrixType operator ^ (const Derived& p ) const { return this->cross(p); }

inline Derived& HomoNormalize()
{
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        enum {
         SubRows = (int(Flags)&RowMajorBit) ? 1 : (RowsAtCompileTime==Dynamic ? Dynamic : RowsAtCompileTime-1),
         SubCols = (int(Flags)&RowMajorBit) ? (ColsAtCompileTime==Dynamic ? Dynamic : ColsAtCompileTime-1) : 1,
        };
        Scalar& last = coeffRef(size()-2);
        if (last!=Scalar(0))
        {
                Block<Derived,SubRows,SubCols>(derived(),0,0,
                        (int(Flags)&RowMajorBit) ? size()-1 : 1,
                        (int(Flags)&RowMajorBit) ? 1 : (size()-1)) / last;
                last = Scalar(1.0);
        }
        return *this;
}

inline const PlainMatrixType HomoNormalize() const
{
        PlainMatrixType res = derived();
        return res.HomoNormalize();
}

EIGEN_DEPRECATED inline Scalar NormInfinity() const { return derived().cwise().abs().maxCoeff(); }
EIGEN_DEPRECATED inline Scalar NormOne() const { return derived().cwise().abs().sum(); }


EIGEN_DEPRECATED inline Scalar Sum() const { return sum(); }
EIGEN_DEPRECATED inline Scalar Max() const { return maxCoeff(); }
EIGEN_DEPRECATED inline Scalar Min() const { return minCoeff(); }
EIGEN_DEPRECATED inline int MaxI() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); int i; maxCoeff(&i,0); return i; }
EIGEN_DEPRECATED inline int MinI() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); int i; minCoeff(&i,0); return i; }


inline Scalar Ext( const int i ) const
{
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived);

        if(i>=0 && i<SizeAtCompileTime)
                return coeff(i);
        else
                return Scalar(0);
}


template<typename OtherDerived>
EIGEN_DEPRECATED inline Derived& Scale(const MatrixBase<OtherDerived>& other)
{ this->cwise() *= other; return derived; }

template<typename OtherDerived>
EIGEN_DEPRECATED inline
CwiseBinaryOp<ei_scalar_product_op<Scalar>, Derived, OtherDerived>
Scale(const MatrixBase<OtherDerived>& other) const
{ return this->cwise() * other; }


template<typename OtherDerived>
EIGEN_DEPRECATED inline bool operator <  (const MatrixBase<OtherDerived>& other) const {
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived);
        return ei_lexi_comparison<Derived,OtherDerived,SizeAtCompileTime>::less(derived(),other.derived());
}

template<typename OtherDerived>
EIGEN_DEPRECATED inline bool operator >  (const MatrixBase<OtherDerived>& other) const {
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived);
        return ei_lexi_comparison<Derived,OtherDerived,SizeAtCompileTime>::geater(derived(),other.derived());
}

template<typename OtherDerived>
EIGEN_DEPRECATED inline bool operator <=  (const MatrixBase<OtherDerived>& other) const {
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived);
        return ei_lexi_comparison<Derived,OtherDerived,SizeAtCompileTime>::lessEqual(derived(),other.derived());
}

template<typename OtherDerived>
EIGEN_DEPRECATED inline bool operator >=  (const MatrixBase<OtherDerived>& other) const {
        EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
        EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived);
        return ei_lexi_comparison<Derived,OtherDerived,SizeAtCompileTime>::greaterEqual(derived(),other.derived());
}