GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-10 18:59:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

release alpha4, Gael edition

Browse Source
This commit is contained in:
Benoit Jacob 2008-02-29 14:50:11 +00:00
parent a2f8d4be6a
commit ed20f64d68
5 changed files with 7 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
Eigen/src/Core/Difference.h
View File

@ -1,104 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra. Eigen itself is part of the KDE project.
//
// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.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_DIFFERENCE_H
#define EIGEN_DIFFERENCE_H
/** \class Difference
*
* \brief Expression of the difference (substraction) of two matrices or vectors
*
* \param Lhs the type of the left-hand side
* \param Rhs the type of the right-hand side
*
* This class represents an expression of the difference of two matrices or vectors.
* It is the return type of the operator- between matrices or vectors, and most
* of the time this is the only way it is used.
*
* \sa class Sum, class Opposite
*/
template<typename Lhs, typename Rhs> class Difference : NoOperatorEquals,
public MatrixBase<typename Lhs::Scalar, Difference<Lhs, Rhs> >
{
public:
typedef typename Lhs::Scalar Scalar;
typedef typename Lhs::Ref LhsRef;
typedef typename Rhs::Ref RhsRef;
friend class MatrixBase<Scalar, Difference>;
typedef MatrixBase<Scalar, Difference> Base;
Difference(const LhsRef& lhs, const RhsRef& rhs)
: m_lhs(lhs), m_rhs(rhs)
{
assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
}
private:
enum {
RowsAtCompileTime = Lhs::Traits::RowsAtCompileTime,
ColsAtCompileTime = Lhs::Traits::ColsAtCompileTime,
MaxRowsAtCompileTime = Lhs::Traits::MaxRowsAtCompileTime,
MaxColsAtCompileTime = Lhs::Traits::MaxColsAtCompileTime
};
const Difference& _ref() const { return *this; }
int _rows() const { return m_lhs.rows(); }
int _cols() const { return m_lhs.cols(); }
Scalar _coeff(int row, int col) const
{
return m_lhs.coeff(row, col) - m_rhs.coeff(row, col);
}
protected:
const LhsRef m_lhs;
const RhsRef m_rhs;
};
/** \relates MatrixBase
*
* \returns an expression of the difference of \a mat1 and \a mat2
*
* \sa class Difference, MatrixBase::operator-=()
*/
template<typename Scalar, typename Derived1, typename Derived2>
const Difference<Derived1, Derived2>
operator-(const MatrixBase<Scalar, Derived1> &mat1, const MatrixBase<Scalar, Derived2> &mat2)
{
return Difference<Derived1, Derived2>(mat1.ref(), mat2.ref());
}
/** replaces \c *this by \c *this - \a other.
*
* \returns a reference to \c *this
*/
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Derived &
MatrixBase<Scalar, Derived>::operator-=(const MatrixBase<Scalar, OtherDerived> &other)
{
return *this = *this - other;
}
#endif // EIGEN_DIFFERENCE_H

129
Eigen/src/Core/FixedBlock.h
View File

@ -1,129 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra. Eigen itself is part of the KDE project.
//
// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.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_FIXEDBLOCK_H
#define EIGEN_FIXEDBLOCK_H
/** \class FixedBlock
*
* \brief Expression of a fixed-size block
*
* \param MatrixType the type of the object in which we are taking a block
* \param BlockRows the number of rows of the block we are taking
* \param BlockCols the number of columns of the block we are taking
*
* This class represents an expression of a fixed-size block. It is the return
* type of MatrixBase::fixedBlock() and most of the time this is the only way it
* is used.
*
* However, if you want to directly maniputate fixed-size block expressions,
* for instance if you want to write a function returning such an expression, you
* will need to use this class.
*
* Here is an example illustrating this:
* \include class_FixedBlock.cpp
* Output: \verbinclude class_FixedBlock.out
*
* \sa MatrixBase::fixedBlock(int,int), class Block
*/
template<typename MatrixType, int BlockRows, int BlockCols> class FixedBlock
: public MatrixBase<typename MatrixType::Scalar,
FixedBlock<MatrixType, BlockRows, BlockCols> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class MatrixBase<Scalar, FixedBlock>;
typedef MatrixBase<Scalar, FixedBlock> Base;
FixedBlock(const MatRef& matrix, int startRow, int startCol)
: m_matrix(matrix), m_startRow(startRow), m_startCol(startCol)
{
assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
&& startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
}
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(FixedBlock)
private:
enum{
RowsAtCompileTime = BlockRows,
ColsAtCompileTime = BlockCols,
MaxRowsAtCompileTime = BlockRows,
MaxColsAtCompileTime = BlockCols
};
const FixedBlock& _ref() const { return *this; }
static int _rows() { return BlockRows; }
static int _cols() { return BlockCols; }
Scalar& _coeffRef(int row, int col)
{
return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
}
Scalar _coeff(int row, int col) const
{
return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
}
protected:
MatRef m_matrix;
IntAtRunTimeIfDynamic<MatrixType::Traits::RowsAtCompileTime == 1 ? 0 : Dynamic>
m_startRow;
IntAtRunTimeIfDynamic<MatrixType::Traits::ColsAtCompileTime == 1 ? 0 : Dynamic>
m_startCol;
};
/** \returns a fixed-size expression of a block in *this.
*
* The template parameters \a BlockRows and \a BlockCols are the number of
* rows and columns in the block.
*
* \param startRow the first row in the block
* \param startCol the first column in the block
*
* Example: \include MatrixBase_fixedBlock_int_int.cpp
* Output: \verbinclude MatrixBase_fixedBlock_int_int.out
*
* \sa class FixedBlock, block(int,int,int,int)
*/
template<typename Scalar, typename Derived>
template<int BlockRows, int BlockCols>
FixedBlock<Derived, BlockRows, BlockCols> MatrixBase<Scalar, Derived>
::fixedBlock(int startRow, int startCol)
{
return FixedBlock<Derived, BlockRows, BlockCols>(ref(), startRow, startCol);
}
/** This is the const version of fixedBlock(int, int). */
template<typename Scalar, typename Derived>
template<int BlockRows, int BlockCols>
const FixedBlock<Derived, BlockRows, BlockCols> MatrixBase<Scalar, Derived>
::fixedBlock(int startRow, int startCol) const
{
return FixedBlock<Derived, BlockRows, BlockCols>(ref(), startRow, startCol);
}
#endif // EIGEN_FIXEDBLOCK_H

104
Eigen/src/Core/Sum.h
View File

@ -1,104 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra. Eigen itself is part of the KDE project.
//
// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.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_SUM_H
#define EIGEN_SUM_H
/** \class Sum
*
* \brief Expression of the sum of two matrices or vectors
*
* \param Lhs the type of the left-hand side
* \param Rhs the type of the right-hand side
*
* This class represents an expression of the sum of two matrices or vectors.
* It is the return type of the operator+ between matrices or vectors, and most
* of the time this is the only way it is used.
*
* \sa class Difference
*/
template<typename Lhs, typename Rhs> class Sum : NoOperatorEquals,
public MatrixBase<typename Lhs::Scalar, Sum<Lhs, Rhs> >
{
public:
typedef typename Lhs::Scalar Scalar;
typedef typename Lhs::Ref LhsRef;
typedef typename Rhs::Ref RhsRef;
friend class MatrixBase<Scalar, Sum>;
typedef MatrixBase<Scalar, Sum> Base;
Sum(const LhsRef& lhs, const RhsRef& rhs)
: m_lhs(lhs), m_rhs(rhs)
{
assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
}
private:
enum {
RowsAtCompileTime = Lhs::Traits::RowsAtCompileTime,
ColsAtCompileTime = Lhs::Traits::ColsAtCompileTime,
MaxRowsAtCompileTime = Lhs::Traits::MaxRowsAtCompileTime,
MaxColsAtCompileTime = Lhs::Traits::MaxColsAtCompileTime
};
const Sum& _ref() const { return *this; }
int _rows() const { return m_lhs.rows(); }
int _cols() const { return m_lhs.cols(); }
Scalar _coeff(int row, int col) const
{
return m_lhs.coeff(row, col) + m_rhs.coeff(row, col);
}
protected:
const LhsRef m_lhs;
const RhsRef m_rhs;
};
/** \relates MatrixBase
*
* \returns an expression of the sum of \a mat1 and \a mat2
*
* \sa class Sum, MatrixBase::operator+=()
*/
template<typename Scalar, typename Derived1, typename Derived2>
const Sum<Derived1, Derived2>
operator+(const MatrixBase<Scalar, Derived1> &mat1, const MatrixBase<Scalar, Derived2> &mat2)
{
return Sum<Derived1, Derived2>(mat1.ref(), mat2.ref());
}
/** replaces \c *this by \c *this + \a other.
*
* \returns a reference to \c *this
*/
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Derived &
MatrixBase<Scalar, Derived>::operator+=(const MatrixBase<Scalar, OtherDerived>& other)
{
return *this = *this + other;
}
#endif // EIGEN_SUM_H

2
doc/Doxyfile.in
View File

@ -5,7 +5,7 @@
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8 DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = Eigen PROJECT_NAME = Eigen
PROJECT_NUMBER = 2.0-alpha3.1 PROJECT_NUMBER = 2.0-alpha4
OUTPUT_DIRECTORY = ${CMAKE_BINARY_DIR}/doc OUTPUT_DIRECTORY = ${CMAKE_BINARY_DIR}/doc
CREATE_SUBDIRS = NO CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English OUTPUT_LANGUAGE = English

14
doc/Mainpage.dox
View File

@ -11,7 +11,7 @@ o /** @mainpage Eigen
<a href="#kde">Relation to KDE</a><br/> <a href="#kde">Relation to KDE</a><br/>
<a href="#examples">Examples</a><br/> <a href="#examples">Examples</a><br/>
<a href="#applications">Applications using Eigen</a><br/> <a href="#applications">Applications using Eigen</a><br/>
<a href="#authors">Authors</a><br/> <a href="#credits">Credits</a><br/>
<a href="#contact">Contact us</a><br/> <a href="#contact">Contact us</a><br/>
<a href="#mailinglist">Mailing list</a><br/> <a href="#mailinglist">Mailing list</a><br/>
@ -82,7 +82,7 @@ If you want to stay informed of Eigen news and releases, please subscribe to our
<a name="download"></a> <a name="download"></a>
<h2>Download</h2> <h2>Download</h2>
The source code of the latest release is here: <a href="http://download.tuxfamily.org/eigen/eigen-2.0-alpha3.1.tar.gz">eigen-2.0-alpha3.1.tar.gz</a><br/> The source code of the latest release is here: <a href="http://download.tuxfamily.org/eigen/eigen-2.0-alpha4.tar.gz">eigen-2.0-alpha4.tar.gz</a><br/>
Alternatively, you can checkout the development tree by anonymous svn, by doing: Alternatively, you can checkout the development tree by anonymous svn, by doing:
<pre>svn co svn://anonsvn.kde.org/home/kde/branches/work/eigen2</pre> <pre>svn co svn://anonsvn.kde.org/home/kde/branches/work/eigen2</pre>
@ -120,14 +120,12 @@ Planned: much more use in KOffice 2.1, Step (if we make Eigen good enough!)
Please tell us if you know of other interesting projects using Eigen! Please tell us if you know of other interesting projects using Eigen!
<a name="authors"></a> <a name="credits"></a>
<h2>Authors</h2> <h2>Credits</h2>
<b>Main Developer:</b> Benoit Jacob (jacob at math jussieu fr)
<b>Contributors during the Eigen 2 development process:</b>
<ul> <ul>
<li>Gael Guennebaud (gael guennebaud at gmail com) : Intel compiler (ICC) support <li>Benoit Jacob (jacob at math jussieu fr) : Main developer</li>
<li>Gael Guennebaud (gael guennebaud at gmail com) : Large contributions</li>
<li>Christian Mayer (mail at christianmayer de) : reviewed the source code, made many useful suggestions</li> <li>Christian Mayer (mail at christianmayer de) : reviewed the source code, made many useful suggestions</li>
<li>Michael Olbrich (michael olbrich at gmx net) : initial loop-unrolling metaprogram</li> <li>Michael Olbrich (michael olbrich at gmx net) : initial loop-unrolling metaprogram</li>
<li>and thanks to everyone on the <a href="#mailinglist">mailing list</a> for your input! <li>and thanks to everyone on the <a href="#mailinglist">mailing list</a> for your input!