mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-08-13 20:26:03 +08:00
Fix all doxygen warnings.
This commit is contained in:
C. Antonio Sanchez
parent
88cd53774e
commit
7312765992
@ -172,7 +172,8 @@ seqN(FirstType first, SizeType size) {
|
||||
return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size);
|
||||
}
|
||||
|
||||
#ifdef EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
#if EIGEN_HAS_CXX11
|
||||
|
||||
/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and with positive (or negative) increment \a incr
|
||||
*
|
||||
@ -183,24 +184,6 @@ seqN(FirstType first, SizeType size) {
|
||||
*
|
||||
* \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)
|
||||
*/
|
||||
template<typename FirstType,typename LastType, typename IncrType>
|
||||
auto seq(FirstType f, LastType l, IncrType incr);
|
||||
|
||||
/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment
|
||||
*
|
||||
* It is essentially an alias to:
|
||||
* \code
|
||||
* seqN(f,l-f+1);
|
||||
* \endcode
|
||||
*
|
||||
* \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)
|
||||
*/
|
||||
template<typename FirstType,typename LastType>
|
||||
auto seq(FirstType f, LastType l);
|
||||
|
||||
#else // EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
#if EIGEN_HAS_CXX11
|
||||
template<typename FirstType,typename LastType>
|
||||
auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
|
||||
( typename internal::cleanup_index_type<LastType>::type(l)
|
||||
@ -211,6 +194,15 @@ auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_in
|
||||
-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
|
||||
}
|
||||
|
||||
/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment
|
||||
*
|
||||
* It is essentially an alias to:
|
||||
* \code
|
||||
* seqN(f,l-f+1);
|
||||
* \endcode
|
||||
*
|
||||
* \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)
|
||||
*/
|
||||
template<typename FirstType,typename LastType, typename IncrType>
|
||||
auto seq(FirstType f, LastType l, IncrType incr)
|
||||
-> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
|
||||
@ -317,26 +309,12 @@ seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<Last
|
||||
}
|
||||
#endif // EIGEN_HAS_CXX11
|
||||
|
||||
#endif // EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
|
||||
#if EIGEN_HAS_CXX11 || defined(EIGEN_PARSED_BY_DOXYGEN)
|
||||
/** \cpp11
|
||||
* \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
|
||||
*
|
||||
* It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode
|
||||
*
|
||||
* \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
|
||||
template<typename SizeType,typename IncrType>
|
||||
auto lastN(SizeType size, IncrType incr)
|
||||
-> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr))
|
||||
{
|
||||
return seqN(Eigen::last-(size-fix<1>())*incr, size, incr);
|
||||
}
|
||||
|
||||
#if EIGEN_HAS_CXX11
|
||||
/** \cpp11
|
||||
* \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment.
|
||||
*
|
||||
* \anchor indexing_lastN
|
||||
*
|
||||
* It is a shortcut for: \code seq(last+fix<1>-size, last) \endcode
|
||||
*
|
||||
* \sa lastN(SizeType,IncrType, seqN(FirstType,SizeType), seq(FirstType,LastType) */
|
||||
@ -346,6 +324,21 @@ auto lastN(SizeType size)
|
||||
{
|
||||
return seqN(Eigen::last+fix<1>()-size, size);
|
||||
}
|
||||
|
||||
/** \cpp11
|
||||
* \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
|
||||
*
|
||||
* \anchor indexing_lastN_with_incr
|
||||
*
|
||||
* It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode
|
||||
*
|
||||
* \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
|
||||
template<typename SizeType,typename IncrType>
|
||||
auto lastN(SizeType size, IncrType incr)
|
||||
-> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr))
|
||||
{
|
||||
return seqN(Eigen::last-(size-fix<1>())*incr, size, incr);
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace internal {
|
||||
|
||||
@ -163,7 +163,15 @@ class Array
|
||||
#endif
|
||||
|
||||
#if EIGEN_HAS_CXX11
|
||||
/** \copydoc PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
|
||||
/** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
|
||||
*
|
||||
* \only_for_vectors
|
||||
*
|
||||
* This constructor is for 1D array or vectors with more than 4 coefficients.
|
||||
* There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
|
||||
*
|
||||
* \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
|
||||
* constructor must match the the fixed number of rows (resp. columns) of \c *this.
|
||||
*
|
||||
* Example: \include Array_variadic_ctor_cxx11.cpp
|
||||
* Output: \verbinclude Array_variadic_ctor_cxx11.out
|
||||
|
||||
@ -292,7 +292,7 @@ DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high)
|
||||
}
|
||||
|
||||
/**
|
||||
* \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&)
|
||||
* \copydoc DenseBase::LinSpaced(Index, const DenseBase::Scalar&, const DenseBase::Scalar&)
|
||||
* Special version for fixed size types which does not require the size parameter.
|
||||
*/
|
||||
template<typename Derived>
|
||||
|
||||
@ -225,8 +225,6 @@ class Matrix
|
||||
return Base::_set(other);
|
||||
}
|
||||
|
||||
/* Here, doxygen failed to copy the brief information when using \copydoc */
|
||||
|
||||
/**
|
||||
* \brief Copies the generic expression \a other into *this.
|
||||
* \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
|
||||
@ -284,7 +282,15 @@ class Matrix
|
||||
#endif
|
||||
|
||||
#if EIGEN_HAS_CXX11
|
||||
/** \copydoc PlainObjectBase(const Scalar&, const Scalar&, const Scalar&, const Scalar&, const ArgTypes&... args)
|
||||
/** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
|
||||
*
|
||||
* \only_for_vectors
|
||||
*
|
||||
* This constructor is for 1D array or vectors with more than 4 coefficients.
|
||||
* There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
|
||||
*
|
||||
* \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
|
||||
* constructor must match the the fixed number of rows (resp. columns) of \c *this.
|
||||
*
|
||||
* Example: \include Matrix_variadic_ctor_cxx11.cpp
|
||||
* Output: \verbinclude Matrix_variadic_ctor_cxx11.out
|
||||
@ -297,6 +303,8 @@ class Matrix
|
||||
: Base(a0, a1, a2, a3, args...) {}
|
||||
|
||||
/** \brief Constructs a Matrix and initializes it from the coefficients given as initializer-lists grouped by row. \cpp11
|
||||
*
|
||||
* \anchor matrix_constructor_initializer_list
|
||||
*
|
||||
* In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
|
||||
*
|
||||
@ -480,16 +488,21 @@ class Matrix
|
||||
|
||||
#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
|
||||
/** \ingroup matrixtypedefs */ \
|
||||
/** \brief \noop */ \
|
||||
typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix; \
|
||||
/** \ingroup matrixtypedefs */ \
|
||||
/** \brief \noop */ \
|
||||
typedef Matrix<Type, Size, 1> Vector##SizeSuffix##TypeSuffix; \
|
||||
/** \ingroup matrixtypedefs */ \
|
||||
/** \brief \noop */ \
|
||||
typedef Matrix<Type, 1, Size> RowVector##SizeSuffix##TypeSuffix;
|
||||
|
||||
#define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \
|
||||
/** \ingroup matrixtypedefs */ \
|
||||
/** \brief \noop */ \
|
||||
typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix; \
|
||||
/** \ingroup matrixtypedefs */ \
|
||||
/** \brief \noop */ \
|
||||
typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
|
||||
|
||||
#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
|
||||
|
||||
@ -98,6 +98,7 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src& src) {
|
||||
}
|
||||
} // namespace numext
|
||||
|
||||
// clang-format off
|
||||
/** \class NumTraits
|
||||
* \ingroup Core_Module
|
||||
*
|
||||
@ -109,45 +110,47 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src& src) {
|
||||
*
|
||||
* The provided data consists of:
|
||||
* \li A typedef \c Real, giving the "real part" type of \a T. If \a T is already real,
|
||||
* then \c Real is just a typedef to \a T. If \a T is \c std::complex<U> then \c Real
|
||||
* then \c Real is just a typedef to \a T. If \a T is `std::complex<U>` then \c Real
|
||||
* is a typedef to \a U.
|
||||
* \li A typedef \c NonInteger, giving the type that should be used for operations producing non-integral values,
|
||||
* such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives
|
||||
* \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to
|
||||
* \a T again. Note however that many Eigen functions such as `internal::sqrt` simply refuse to
|
||||
* take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is
|
||||
* only intended as a helper for code that needs to explicitly promote types.
|
||||
* \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for \c std::complex<U>, Literal is defined as \c U.
|
||||
* \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for `std::complex<U>`,
|
||||
* Literal is defined as \c U.
|
||||
* Of course, this type must be fully compatible with \a T. In doubt, just use \a T here.
|
||||
* \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what
|
||||
* \li A typedef \c Nested giving the type to use to nest a value inside of the expression tree. If you don't know what
|
||||
* this means, just use \a T here.
|
||||
* \li An enum value \a IsComplex. It is equal to 1 if \a T is a \c std::complex
|
||||
* \li An enum value \c IsComplex. It is equal to 1 if \a T is a \c std::complex
|
||||
* type, and to 0 otherwise.
|
||||
* \li An enum value \a IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int,
|
||||
* \li An enum value \c IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int,
|
||||
* and to \c 0 otherwise.
|
||||
* \li Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed
|
||||
* \li Enum values \c ReadCost, \c AddCost and \c MulCost representing a rough estimate of the number of CPU cycles needed
|
||||
* to by move / add / mul instructions respectively, assuming the data is already stored in CPU registers.
|
||||
* Stay vague here. No need to do architecture-specific stuff. If you don't know what this means, just use \c Eigen::HugeCost.
|
||||
* \li An enum value \a IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
|
||||
* \li An enum value \a RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must
|
||||
* \li An enum value \c IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
|
||||
* \li An enum value \c RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must
|
||||
* be called, and to 0 if it is safe not to call it. Default is 0 if \a T is an arithmetic type, and 1 otherwise.
|
||||
* \li An epsilon() function which, unlike <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon">std::numeric_limits::epsilon()</a>,
|
||||
* it returns a \a Real instead of a \a T.
|
||||
* \li A dummy_precision() function returning a weak epsilon value. It is mainly used as a default
|
||||
* \li An `epsilon()` function which, unlike <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon">`std::numeric_limits::epsilon()`</a>,
|
||||
* it returns a \c Real instead of a \a T.
|
||||
* \li A `dummy_precision()` function returning a weak epsilon value. It is mainly used as a default
|
||||
* value by the fuzzy comparison operators.
|
||||
* \li highest() and lowest() functions returning the highest and lowest possible values respectively.
|
||||
* \li digits() function returning the number of radix digits (non-sign digits for integers, mantissa for floating-point). This is
|
||||
* \li `highest()` and `lowest()` functions returning the highest and lowest possible values respectively.
|
||||
* \li `digits()` function returning the number of radix digits (non-sign digits for integers, mantissa for floating-point). This is
|
||||
* the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits">std::numeric_limits<T>::digits</a>
|
||||
* which is used as the default implementation if specialized.
|
||||
* \li digits10() function returning the number of decimal digits that can be represented without change. This is
|
||||
* \li `digits10()` function returning the number of decimal digits that can be represented without change. This is
|
||||
* the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits10">std::numeric_limits<T>::digits10</a>
|
||||
* which is used as the default implementation if specialized.
|
||||
* \li min_exponent() and max_exponent() functions returning the highest and lowest possible values, respectively,
|
||||
* \li `min_exponent()` and `max_exponent()` functions returning the highest and lowest possible values, respectively,
|
||||
* such that the radix raised to the power exponent-1 is a normalized floating-point number. These are equivalent to
|
||||
* <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent">std::numeric_limits<T>::min_exponent</a>/
|
||||
* <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent">std::numeric_limits<T>::max_exponent</a>.
|
||||
* \li infinity() function returning a representation of positive infinity, if available.
|
||||
* \li quiet_NaN function returning a non-signaling "not-a-number", if available.
|
||||
* <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent">`std::numeric_limits<T>::min_exponent`</a>/
|
||||
* <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent">`std::numeric_limits<T>::max_exponent`</a>.
|
||||
* \li `infinity()` function returning a representation of positive infinity, if available.
|
||||
* \li `quiet_NaN` function returning a non-signaling "not-a-number", if available.
|
||||
*/
|
||||
// clang-format on
|
||||
|
||||
template<typename T> struct GenericNumTraits
|
||||
{
|
||||
|
||||
@ -100,12 +100,10 @@ template<typename Derived> class TriangularBase : public EigenBase<Derived>
|
||||
return coeffRef(row,col);
|
||||
}
|
||||
|
||||
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
||||
EIGEN_DEVICE_FUNC
|
||||
inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
|
||||
EIGEN_DEVICE_FUNC
|
||||
inline Derived& derived() { return *static_cast<Derived*>(this); }
|
||||
#endif // not EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
template<typename DenseDerived>
|
||||
EIGEN_DEVICE_FUNC
|
||||
@ -442,7 +440,6 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
|
||||
EIGEN_DEVICE_FUNC
|
||||
TriangularViewType& operator=(const MatrixBase<OtherDerived>& other);
|
||||
|
||||
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
||||
EIGEN_DEVICE_FUNC
|
||||
TriangularViewType& operator=(const TriangularViewImpl& other)
|
||||
{ return *this = other.derived().nestedExpression(); }
|
||||
@ -456,7 +453,6 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
|
||||
/** \deprecated */
|
||||
EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
|
||||
void lazyAssign(const MatrixBase<OtherDerived>& other);
|
||||
#endif
|
||||
|
||||
/** Efficient triangular matrix times vector/matrix product */
|
||||
template<typename OtherDerived>
|
||||
@ -524,11 +520,7 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
|
||||
/** Swaps the coefficients of the common triangular parts of two matrices */
|
||||
template<typename OtherDerived>
|
||||
EIGEN_DEVICE_FUNC
|
||||
#ifdef EIGEN_PARSED_BY_DOXYGEN
|
||||
void swap(TriangularBase<OtherDerived> &other)
|
||||
#else
|
||||
void swap(TriangularBase<OtherDerived> const & other)
|
||||
#endif
|
||||
{
|
||||
EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
|
||||
call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
|
||||
@ -552,9 +544,10 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
|
||||
this->solveInPlace(dst);
|
||||
}
|
||||
|
||||
template<typename ProductType>
|
||||
EIGEN_DEVICE_FUNC
|
||||
EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(const ProductType& prod, const Scalar& alpha, bool beta);
|
||||
template <typename ProductType>
|
||||
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(const ProductType& prod, const Scalar& alpha,
|
||||
bool beta);
|
||||
|
||||
protected:
|
||||
EIGEN_DEFAULT_COPY_CONSTRUCTOR(TriangularViewImpl)
|
||||
EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TriangularViewImpl)
|
||||
|
||||
@ -15,7 +15,9 @@ namespace Eigen {
|
||||
|
||||
namespace internal {
|
||||
|
||||
static Packet4ui p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
|
||||
inline Packet4ui p4ui_CONJ_XOR() {
|
||||
return vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
|
||||
}
|
||||
#ifdef EIGEN_VECTORIZE_VSX
|
||||
#if defined(_BIG_ENDIAN)
|
||||
static Packet2ul p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
|
||||
@ -44,7 +46,7 @@ struct Packet2cf
|
||||
v1 = vec_madd(v1, b.v, p4f_ZERO);
|
||||
// multiply a_im * b and get the conjugate result
|
||||
v2 = vec_madd(v2, b.v, p4f_ZERO);
|
||||
v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR)));
|
||||
v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR())));
|
||||
// permute back to a proper order
|
||||
v2 = vec_perm(v2, v2, p16uc_COMPLEX32_REV);
|
||||
|
||||
@ -165,7 +167,7 @@ template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v + b.v); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v - b.v); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR()))); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pand <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v, b.v)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v, b.v)); }
|
||||
|
||||
@ -16,7 +16,9 @@ namespace Eigen {
|
||||
namespace internal {
|
||||
|
||||
#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
|
||||
static Packet4ui p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; //vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);
|
||||
inline Packet4ui p4ui_CONJ_XOR() {
|
||||
return { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; //vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);
|
||||
}
|
||||
#endif
|
||||
|
||||
static Packet2ul p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
|
||||
@ -345,7 +347,7 @@ template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packe
|
||||
Packet4f tmp = { eq[1], eq[0], eq[3], eq[2] };
|
||||
return (Packet2cf)pand<Packet4f>(eq, tmp);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR()))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
|
||||
{
|
||||
Packet4f a_re, a_im, prod, prod_im;
|
||||
@ -358,7 +360,7 @@ template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, con
|
||||
|
||||
// multiply a_im * b and get the conjugate result
|
||||
prod_im = a_im * b.v;
|
||||
prod_im = pxor<Packet4f>(prod_im, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR));
|
||||
prod_im = pxor<Packet4f>(prod_im, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR()));
|
||||
// permute back to a proper order
|
||||
prod_im = vec_perm(prod_im, prod_im, p16uc_COMPLEX32_REV);
|
||||
|
||||
|
||||
@ -300,14 +300,19 @@ struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,false>
|
||||
}
|
||||
};
|
||||
|
||||
template<typename MatrixType, unsigned int UpLo>
|
||||
template<typename ProductType>
|
||||
EIGEN_DEVICE_FUNC TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::_assignProduct(const ProductType& prod, const Scalar& alpha, bool beta)
|
||||
{
|
||||
EIGEN_STATIC_ASSERT((UpLo&UnitDiag)==0, WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
|
||||
template <typename _MatrixType, unsigned int _Mode>
|
||||
template <typename ProductType>
|
||||
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename TriangularViewImpl<_MatrixType, _Mode, Dense>::TriangularViewType&
|
||||
TriangularViewImpl<_MatrixType, _Mode, Dense>::_assignProduct(
|
||||
const ProductType& prod, const typename TriangularViewImpl<_MatrixType, _Mode, Dense>::Scalar& alpha, bool beta) {
|
||||
EIGEN_STATIC_ASSERT((_Mode & UnitDiag) == 0, WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
|
||||
eigen_assert(derived().nestedExpression().rows() == prod.rows() && derived().cols() == prod.cols());
|
||||
|
||||
general_product_to_triangular_selector<MatrixType, ProductType, UpLo, internal::traits<ProductType>::InnerSize==1>::run(derived().nestedExpression().const_cast_derived(), prod, alpha, beta);
|
||||
general_product_to_triangular_selector<_MatrixType, ProductType, _Mode,
|
||||
internal::traits<ProductType>::InnerSize == 1>::run(derived()
|
||||
.nestedExpression()
|
||||
.const_cast_derived(),
|
||||
prod, alpha, beta);
|
||||
|
||||
return derived();
|
||||
}
|
||||
|
||||
@ -168,7 +168,7 @@ template<int Size> struct get_compile_time_incr<AllRange<Size> > {
|
||||
* \ingroup Core_Module
|
||||
* Can be used as a parameter to DenseBase::operator()(const RowIndices&, const ColIndices&) to index all rows or columns
|
||||
*/
|
||||
static const Eigen::internal::all_t all; // PLEASE use Eigen::all instead of Eigen::placeholders::all
|
||||
static const Eigen::internal::all_t all;
|
||||
|
||||
|
||||
namespace placeholders {
|
||||
|
||||
@ -14,7 +14,9 @@
|
||||
namespace Eigen {
|
||||
|
||||
/** \ingroup Householder_Module
|
||||
*
|
||||
* \householder_module
|
||||
*
|
||||
* \class HouseholderSequence
|
||||
* \brief Sequence of Householder reflections acting on subspaces with decreasing size
|
||||
* \tparam VectorsType type of matrix containing the Householder vectors
|
||||
@ -518,7 +520,10 @@ typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,Ot
|
||||
return res;
|
||||
}
|
||||
|
||||
/** \ingroup Householder_Module \householder_module
|
||||
/** \ingroup Householder_Module
|
||||
*
|
||||
* \householder_module
|
||||
*
|
||||
* \brief Convenience function for constructing a Householder sequence.
|
||||
* \returns A HouseholderSequence constructed from the specified arguments.
|
||||
*/
|
||||
@ -528,7 +533,10 @@ HouseholderSequence<VectorsType,CoeffsType> householderSequence(const VectorsTyp
|
||||
return HouseholderSequence<VectorsType,CoeffsType,OnTheLeft>(v, h);
|
||||
}
|
||||
|
||||
/** \ingroup Householder_Module \householder_module
|
||||
/** \ingroup Householder_Module
|
||||
*
|
||||
* \householder_module
|
||||
*
|
||||
* \brief Convenience function for constructing a Householder sequence.
|
||||
* \returns A HouseholderSequence constructed from the specified arguments.
|
||||
* \details This function differs from householderSequence() in that the template argument \p OnTheSide of
|
||||
|
||||
@ -781,14 +781,12 @@ class SparseMatrix
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
||||
template<typename OtherDerived>
|
||||
inline SparseMatrix& operator=(const EigenBase<OtherDerived>& other)
|
||||
{ return Base::operator=(other.derived()); }
|
||||
|
||||
template<typename Lhs, typename Rhs>
|
||||
inline SparseMatrix& operator=(const Product<Lhs,Rhs,AliasFreeProduct>& other);
|
||||
#endif // EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
template<typename OtherDerived>
|
||||
EIGEN_DONT_INLINE SparseMatrix& operator=(const SparseMatrixBase<OtherDerived>& other);
|
||||
|
||||
@ -165,6 +165,7 @@ protected:
|
||||
} // end namespace internal
|
||||
|
||||
// sparse matrix = sparse-product (can be sparse*sparse, sparse*perm, etc.)
|
||||
|
||||
template<typename Scalar, int _Options, typename _StorageIndex>
|
||||
template<typename Lhs, typename Rhs>
|
||||
SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const Product<Lhs,Rhs,AliasFreeProduct>& src)
|
||||
|
||||
@ -69,7 +69,7 @@ namespace internal {
|
||||
* detailed in the following paper:
|
||||
* <i>
|
||||
* Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
|
||||
* Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011.
|
||||
* Sparse QR Factorization", ACM Trans. on Math. Soft. 38(1), 2011.
|
||||
* </i>
|
||||
* Even though it is qualified as "rank-revealing", this strategy might fail for some
|
||||
* rank deficient problems. When this class is used to solve linear or least-square problems
|
||||
|
||||
@ -152,9 +152,6 @@ max
|
||||
}
|
||||
|
||||
/** \returns an expression of the coefficient-wise absdiff of \c *this and \a other
|
||||
*
|
||||
* Example: \include Cwise_absolute_difference.cpp
|
||||
* Output: \verbinclude Cwise_absolute_difference.out
|
||||
*
|
||||
* \sa absolute_difference()
|
||||
*/
|
||||
|
||||
@ -10,16 +10,13 @@ if(CMAKE_COMPILER_IS_GNUCXX)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# some examples and snippets needs c++11, so let's check it once
|
||||
check_cxx_compiler_flag("-std=c++11" EIGEN_COMPILER_SUPPORT_CPP11)
|
||||
|
||||
option(EIGEN_INTERNAL_DOCUMENTATION "Build internal documentation" OFF)
|
||||
option(EIGEN_DOC_USE_MATHJAX "Use MathJax for rendering math in HTML docs" ON)
|
||||
|
||||
# Set some Doxygen flags
|
||||
set(EIGEN_DOXY_PROJECT_NAME "Eigen")
|
||||
set(EIGEN_DOXY_OUTPUT_DIRECTORY_SUFFIX "")
|
||||
set(EIGEN_DOXY_INPUT "\"${Eigen_SOURCE_DIR}/Eigen\" \"${Eigen_SOURCE_DIR}/doc\"")
|
||||
set(EIGEN_DOXY_INPUT "\"${Eigen_SOURCE_DIR}/doc\" \"${Eigen_SOURCE_DIR}/Eigen\"")
|
||||
set(EIGEN_DOXY_HTML_COLORSTYLE_HUE "220")
|
||||
set(EIGEN_DOXY_TAGFILES "")
|
||||
|
||||
@ -42,7 +39,7 @@ configure_file(
|
||||
|
||||
set(EIGEN_DOXY_PROJECT_NAME "Eigen-unsupported")
|
||||
set(EIGEN_DOXY_OUTPUT_DIRECTORY_SUFFIX "/unsupported")
|
||||
set(EIGEN_DOXY_INPUT "\"${Eigen_SOURCE_DIR}/unsupported/Eigen\" \"${Eigen_SOURCE_DIR}/unsupported/doc\"")
|
||||
set(EIGEN_DOXY_INPUT "\"${Eigen_SOURCE_DIR}/unsupported/doc\" \"${Eigen_SOURCE_DIR}/unsupported/Eigen\"")
|
||||
set(EIGEN_DOXY_HTML_COLORSTYLE_HUE "0")
|
||||
set(EIGEN_DOXY_TAGFILES "\"${Eigen_BINARY_DIR}/doc/Eigen.doxytags=..\"")
|
||||
#set(EIGEN_DOXY_TAGFILES "")
|
||||
@ -86,7 +83,6 @@ add_custom_target(
|
||||
doc-eigen-prerequisites
|
||||
ALL
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/html/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/eigen_navtree_hacks.js ${CMAKE_CURRENT_BINARY_DIR}/html/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Eigen_Silly_Professor_64x64.png ${CMAKE_CURRENT_BINARY_DIR}/html/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2pnode.png ${CMAKE_CURRENT_BINARY_DIR}/html/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2node.png ${CMAKE_CURRENT_BINARY_DIR}/html/
|
||||
@ -98,7 +94,6 @@ add_custom_target(
|
||||
doc-unsupported-prerequisites
|
||||
ALL
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory ${Eigen_BINARY_DIR}/doc/html/unsupported
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/eigen_navtree_hacks.js ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Eigen_Silly_Professor_64x64.png ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2pnode.png ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2node.png ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
|
||||
|
||||
@ -313,7 +313,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_cosh
|
||||
a.\link ArrayBase::cosh cohs\endlink(); \n
|
||||
a.\link ArrayBase::cosh cosh\endlink(); \n
|
||||
\link Eigen::cosh cosh\endlink(a);
|
||||
</td>
|
||||
<td>computes hyperbolic cosine</td>
|
||||
@ -505,7 +505,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<td class="code">
|
||||
\anchor cwisetable_digamma
|
||||
a.\link ArrayBase::digamma digamma\endlink(); \n
|
||||
\link Eigen::digamma digamma\endlink(a);
|
||||
digamma(a);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Digamma_function">logarithmic derivative of the gamma function</a></td>
|
||||
<td>
|
||||
@ -516,7 +516,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_igamma
|
||||
\link Eigen::igamma igamma\endlink(a,x);
|
||||
igamma(a,x);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Incomplete_gamma_function">lower incomplete gamma integral</a>
|
||||
\n \f$ \gamma(a_i,x_i)= \frac{1}{|a_i|} \int_{0}^{x_i}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \f$</td>
|
||||
@ -528,7 +528,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_igammac
|
||||
\link Eigen::igammac igammac\endlink(a,x);
|
||||
igammac(a,x);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Incomplete_gamma_function">upper incomplete gamma integral</a>
|
||||
\n \f$ \Gamma(a_i,x_i) = \frac{1}{|a_i|} \int_{x_i}^{\infty}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \f$</td>
|
||||
@ -544,7 +544,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_polygamma
|
||||
\link Eigen::polygamma polygamma\endlink(n,x);
|
||||
polygamma(n,x);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Polygamma_function">n-th derivative of digamma at x</a></td>
|
||||
<td>
|
||||
@ -557,7 +557,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_betainc
|
||||
\link Eigen::betainc betainc\endlink(a,b,x);
|
||||
betainc(a,b,x);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function">Incomplete beta function</a></td>
|
||||
<td>
|
||||
@ -568,7 +568,7 @@ This also means that, unless specified, if the function \c std::foo is available
|
||||
<tr>
|
||||
<td class="code">
|
||||
\anchor cwisetable_zeta
|
||||
\link Eigen::zeta zeta\endlink(a,b); \n
|
||||
zeta(a,b); \n
|
||||
a.\link ArrayBase::zeta zeta\endlink(b);
|
||||
</td>
|
||||
<td><a href="https://en.wikipedia.org/wiki/Hurwitz_zeta_function">Hurwitz zeta function</a>
|
||||
|
||||
1869
doc/Doxyfile.in
1869
doc/Doxyfile.in
File diff suppressed because it is too large
Load Diff
@ -88,7 +88,7 @@ You may wonder, isn't it overengineering to have the storage in a separate class
|
||||
|
||||
Let's look at this constructor, in src/Core/DenseStorage.h. You can see that there are many partial template specializations of DenseStorages here, treating separately the cases where dimensions are Dynamic or fixed at compile-time. The partial specialization that we are looking at is:
|
||||
\code
|
||||
template<typename T, int _Cols> class DenseStorage<T, Dynamic, Dynamic, _Cols>
|
||||
template<typename T, int Cols_> class DenseStorage<T, Dynamic, Dynamic, Cols_>
|
||||
\endcode
|
||||
|
||||
Here, the constructor called is DenseStorage::DenseStorage(int size, int rows, int columns)
|
||||
@ -101,7 +101,7 @@ inline DenseStorage(int size, int rows, int) : m_data(internal::aligned_new<T>(s
|
||||
|
||||
Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own internal::aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[].
|
||||
|
||||
As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of DenseStorage, we know the number of columns at compile-time, since the _Cols template parameter is different from Dynamic. Namely, in our case, _Cols is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
|
||||
As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of DenseStorage, we know the number of columns at compile-time, since the Cols_ template parameter is different from Dynamic. Namely, in our case, Cols_ is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
|
||||
|
||||
When you call VectorXf::data() to get the pointer to the array of coefficients, it returns DenseStorage::data() which returns the \a m_data member.
|
||||
|
||||
@ -278,7 +278,7 @@ So internal::assign_selector takes 4 template parameters, but the 2 last ones ar
|
||||
|
||||
EvalBeforeAssigning is here to enforce the EvalBeforeAssigningBit. As explained <a href="TopicLazyEvaluation.html">here</a>, certain expressions have this flag which makes them automatically evaluate into temporaries before assigning them to another expression. This is the case of the Product expression, in order to avoid strange aliasing effects when doing "m = m * m;" However, of course here our CwiseBinaryOp expression doesn't have the EvalBeforeAssigningBit: we said since the beginning that we didn't want a temporary to be introduced here. So if you go to src/Core/CwiseBinaryOp.h, you'll see that the Flags in internal::traits\<CwiseBinaryOp\> don't include the EvalBeforeAssigningBit. The Flags member of CwiseBinaryOp is then imported from the internal::traits by the EIGEN_GENERIC_PUBLIC_INTERFACE macro. Anyway, here the template parameter EvalBeforeAssigning has the value \c false.
|
||||
|
||||
NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimesions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too.
|
||||
NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimensions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too.
|
||||
|
||||
So, here we are in the partial specialization:
|
||||
\code
|
||||
|
||||
@ -39,7 +39,6 @@ namespace Eigen {
|
||||
- \subpage TopicVectorization
|
||||
- \subpage TopicEigenExpressionTemplates
|
||||
- \subpage TopicScalarTypes
|
||||
- \subpage GettingStarted
|
||||
- \subpage TutorialSparse_example_details
|
||||
- \subpage TopicWritingEfficientProductExpression
|
||||
- \subpage Experimental
|
||||
|
||||
@ -4,7 +4,7 @@ namespace Eigen {
|
||||
|
||||
This is the API documentation for Eigen3. You can <a href="eigen-doc.tgz">download</a> it as a tgz archive for offline reading.
|
||||
|
||||
For a first contact with Eigen, the best place is to have a look at the \link GettingStarted getting started \endlink page that show you how to write and compile your first program with Eigen.
|
||||
For a first contact with Eigen, the best place is to have a look at the \subpage GettingStarted page that show you how to write and compile your first program with Eigen.
|
||||
|
||||
Then, the \b quick \b reference \b pages give you a quite complete description of the API in a very condensed format that is specially useful to recall the syntax of a particular feature, or to have a quick look at the API. They currently cover the two following feature sets, and more will come in the future:
|
||||
- \link QuickRefPage [QuickRef] Dense matrix and array manipulations \endlink
|
||||
@ -19,6 +19,10 @@ Under the \subpage UserManual_CustomizingEigen section, you will find discussion
|
||||
|
||||
Under the \subpage UserManual_Generalities section, you will find documentation on more general topics such as preprocessor directives, controlling assertions, multi-threading, MKL support, some Eigen's internal insights, and much more...
|
||||
|
||||
For details regarding Eigen's inner-workings, see the \subpage UserManual_UnderstandingEigen section.
|
||||
|
||||
Some random topics can be found under the \subpage UnclassifiedPages section.
|
||||
|
||||
Finally, do not miss the search engine, useful to quickly get to the documentation of a given class or function.
|
||||
|
||||
Want more? Checkout the <a href="unsupported/index.html">\em unsupported \em modules </a> documentation.
|
||||
|
||||
@ -29,7 +29,7 @@ are doing.
|
||||
initialized to zero, as are new entries in matrices and arrays after resizing. Not defined by default.
|
||||
\warning The unary (resp. binary) constructor of \c 1x1 (resp. \c 2x1 or \c 1x2) fixed size matrices is
|
||||
always interpreted as an initialization constructor where the argument(s) are the coefficient values
|
||||
and not the sizes. For instance, \code Vector2d v(2,1); \endcode will create a vector with coeficients [2,1],
|
||||
and not the sizes. For instance, \code Vector2d v(2,1); \endcode will create a vector with coefficients [2,1],
|
||||
and \b not a \c 2x1 vector initialized with zeros (i.e., [0,0]). If such cases might occur, then it is
|
||||
recommended to use the default constructor with a explicit call to resize:
|
||||
\code
|
||||
@ -104,7 +104,7 @@ run time. However, these assertions do cost time and can thus be turned off.
|
||||
- \b \c EIGEN_MAX_ALIGN_BYTES - Must be a power of two, or 0. Defines an upper bound on the memory boundary in bytes on which dynamically and statically allocated data may be aligned by %Eigen. If not defined, a default value is automatically computed based on architecture, compiler, and OS.
|
||||
This option is typically used to enforce binary compatibility between code/libraries compiled with different SIMD options. For instance, one may compile AVX code and enforce ABI compatibility with existing SSE code by defining \c EIGEN_MAX_ALIGN_BYTES=16. In the other way round, since by default AVX implies 32 bytes alignment for best performance, one can compile SSE code to be ABI compatible with AVX code by defining \c EIGEN_MAX_ALIGN_BYTES=32.
|
||||
- \b \c EIGEN_MAX_STATIC_ALIGN_BYTES - Same as \c EIGEN_MAX_ALIGN_BYTES but for statically allocated data only. By default, if only \c EIGEN_MAX_ALIGN_BYTES is defined, then \c EIGEN_MAX_STATIC_ALIGN_BYTES == \c EIGEN_MAX_ALIGN_BYTES, otherwise a default value is automatically computed based on architecture, compiler, and OS (can be smaller than the default value of EIGEN_MAX_ALIGN_BYTES on architectures that do not support stack alignment).
|
||||
Let us emphasize that \c EIGEN_MAX_*_ALIGN_BYTES define only a diserable upper bound. In practice data is aligned to largest power-of-two common divisor of \c EIGEN_MAX_STATIC_ALIGN_BYTES and the size of the data, such that memory is not wasted.
|
||||
Let us emphasize that \c EIGEN_MAX_*_ALIGN_BYTES define only a desirable upper bound. In practice data is aligned to largest power-of-two common divisor of \c EIGEN_MAX_STATIC_ALIGN_BYTES and the size of the data, such that memory is not wasted.
|
||||
- \b \c EIGEN_DONT_PARALLELIZE - if defined, this disables multi-threading. This is only relevant if you enabled OpenMP.
|
||||
See \ref TopicMultiThreading for details.
|
||||
- \b \c EIGEN_DONT_VECTORIZE - disables explicit vectorization when defined. Not defined by default, unless
|
||||
|
||||
@ -22,11 +22,11 @@ We will explain the program after telling you how to compile it.
|
||||
|
||||
\section GettingStartedCompiling Compiling and running your first program
|
||||
|
||||
There is no library to link to. The only thing that you need to keep in mind when compiling the above program is that the compiler must be able to find the Eigen header files. The directory in which you placed Eigen's source code must be in the include path. With GCC you use the -I option to achieve this, so you can compile the program with a command like this:
|
||||
There is no library to link to. The only thing that you need to keep in mind when compiling the above program is that the compiler must be able to find the Eigen header files. The directory in which you placed Eigen's source code must be in the include path. With GCC you use the \c -I option to achieve this, so you can compile the program with a command like this:
|
||||
|
||||
\code g++ -I /path/to/eigen/ my_program.cpp -o my_program \endcode
|
||||
|
||||
On Linux or Mac OS X, another option is to symlink or copy the Eigen folder into /usr/local/include/. This way, you can compile the program with:
|
||||
On Linux or Mac OS X, another option is to symlink or copy the Eigen folder into \c /usr/local/include/. This way, you can compile the program with:
|
||||
|
||||
\code g++ my_program.cpp -o my_program \endcode
|
||||
|
||||
@ -66,7 +66,7 @@ The output is as follows:
|
||||
|
||||
\section GettingStartedExplanation2 Explanation of the second example
|
||||
|
||||
The second example starts by declaring a 3-by-3 matrix \c m which is initialized using the \link DenseBase::Random(Index,Index) Random() \endlink method with random values between -1 and 1. The next line applies a linear mapping such that the values are between 10 and 110. The function call \link DenseBase::Constant(Index,Index,const Scalar&) MatrixXd::Constant\endlink(3,3,1.2) returns a 3-by-3 matrix expression having all coefficients equal to 1.2. The rest is standard arithmetic.
|
||||
The second example starts by declaring a 3-by-3 matrix \c m which is initialized using the \link DenseBase::Random(Index,Index) Random() \endlink method with random values between -1 and 1. The next line applies a linear mapping such that the values are between 10 and 110. The function call \link DenseBase::Constant(Index,Index,const DenseBase::Scalar&) MatrixXd::Constant\endlink(3,3,1.2) returns a 3-by-3 matrix expression having all coefficients equal to 1.2. The rest is standard arithmetic.
|
||||
|
||||
The next line of the \c main function introduces a new type: \c VectorXd. This represents a (column) vector of arbitrary size. Here, the vector \c v is created to contain \c 3 coefficients which are left uninitialized. The one but last line uses the so-called comma-initializer, explained in \ref TutorialAdvancedInitialization, to set all coefficients of the vector \c v to be as follows:
|
||||
|
||||
|
||||
@ -42,7 +42,7 @@ They are summarized in the following tables:
|
||||
|
||||
<tr><td>LeastSquaresConjugateGradient \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>CG for rectangular least-square problem</td><td>Rectangular</td>
|
||||
<td>IdentityPreconditioner, [LeastSquareDiagonalPreconditioner]</td>
|
||||
<td>Solve for min |A'Ax-b|^2 without forming A'A</td></tr>
|
||||
<td>Solve for min |Ax-b|^2 without forming A'A</td></tr>
|
||||
|
||||
<tr><td>BiCGSTAB \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Iterative stabilized bi-conjugate gradient</td><td>Square</td>
|
||||
<td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
|
||||
@ -130,7 +130,7 @@ x1 = solver.solve(b1);
|
||||
x2 = solver.solve(b2);
|
||||
...
|
||||
\endcode
|
||||
The compute() method is equivalent to calling both analyzePattern() and factorize().
|
||||
The `compute()` method is equivalent to calling both `analyzePattern()` and `factorize()`.
|
||||
|
||||
Each solver provides some specific features, such as determinant, access to the factors, controls of the iterations, and so on.
|
||||
More details are available in the documentations of the respective classes.
|
||||
@ -138,9 +138,9 @@ More details are available in the documentations of the respective classes.
|
||||
Finally, most of the iterative solvers, can also be used in a \b matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
|
||||
|
||||
\section TheSparseCompute The Compute Step
|
||||
In the compute() function, the matrix is generally factorized: LLT for self-adjoint matrices, LDLT for general hermitian matrices, LU for non hermitian matrices and QR for rectangular matrices. These are the results of using direct solvers. For this class of solvers precisely, the compute step is further subdivided into analyzePattern() and factorize().
|
||||
In the `compute()` function, the matrix is generally factorized: LLT for self-adjoint matrices, LDLT for general hermitian matrices, LU for non hermitian matrices and QR for rectangular matrices. These are the results of using direct solvers. For this class of solvers precisely, the compute step is further subdivided into `analyzePattern()` and `factorize()`.
|
||||
|
||||
The goal of analyzePattern() is to reorder the nonzero elements of the matrix, such that the factorization step creates less fill-in. This step exploits only the structure of the matrix. Hence, the results of this step can be used for other linear systems where the matrix has the same structure. Note however that sometimes, some external solvers (like SuperLU) require that the values of the matrix are set in this step, for instance to equilibrate the rows and columns of the matrix. In this situation, the results of this step should not be used with other matrices.
|
||||
The goal of `analyzePattern()` is to reorder the nonzero elements of the matrix, such that the factorization step creates less fill-in. This step exploits only the structure of the matrix. Hence, the results of this step can be used for other linear systems where the matrix has the same structure. Note however that sometimes, some external solvers (like SuperLU) require that the values of the matrix are set in this step, for instance to equilibrate the rows and columns of the matrix. In this situation, the results of this step should not be used with other matrices.
|
||||
|
||||
Eigen provides a limited set of methods to reorder the matrix in this step, either built-in (COLAMD, AMD) or external (METIS). These methods are set in template parameter list of the solver :
|
||||
\code
|
||||
@ -149,21 +149,21 @@ DirectSolverClassName<SparseMatrix<double>, OrderingMethod<IndexType> > solver;
|
||||
|
||||
See the \link OrderingMethods_Module OrderingMethods module \endlink for the list of available methods and the associated options.
|
||||
|
||||
In factorize(), the factors of the coefficient matrix are computed. This step should be called each time the values of the matrix change. However, the structural pattern of the matrix should not change between multiple calls.
|
||||
In `factorize()`, the factors of the coefficient matrix are computed. This step should be called each time the values of the matrix change. However, the structural pattern of the matrix should not change between multiple calls.
|
||||
|
||||
For iterative solvers, the compute step is used to eventually setup a preconditioner. For instance, with the ILUT preconditioner, the incomplete factors L and U are computed in this step. Remember that, basically, the goal of the preconditioner is to speedup the convergence of an iterative method by solving a modified linear system where the coefficient matrix has more clustered eigenvalues. For real problems, an iterative solver should always be used with a preconditioner. In Eigen, a preconditioner is selected by simply adding it as a template parameter to the iterative solver object.
|
||||
\code
|
||||
IterativeSolverClassName<SparseMatrix<double>, PreconditionerName<SparseMatrix<double> > solver;
|
||||
\endcode
|
||||
The member function preconditioner() returns a read-write reference to the preconditioner
|
||||
The member function `preconditioner()` returns a read-write reference to the preconditioner
|
||||
to directly interact with it. See the \link IterativeLinearSolvers_Module Iterative solvers module \endlink and the documentation of each class for the list of available methods.
|
||||
|
||||
\section TheSparseSolve The Solve step
|
||||
The solve() function computes the solution of the linear systems with one or many right hand sides.
|
||||
The `solve()` function computes the solution of the linear systems with one or many right hand sides.
|
||||
\code
|
||||
X = solver.solve(B);
|
||||
\endcode
|
||||
Here, B can be a vector or a matrix where the columns form the different right hand sides. The solve() function can be called several times as well, for instance when all the right hand sides are not available at once.
|
||||
Here, B can be a vector or a matrix where the columns form the different right hand sides. `The solve()` function can be called several times as well, for instance when all the right hand sides are not available at once.
|
||||
\code
|
||||
x1 = solver.solve(b1);
|
||||
// Get the second right hand side b2
|
||||
@ -173,7 +173,7 @@ x2 = solver.solve(b2);
|
||||
For direct methods, the solution are computed at the machine precision. Sometimes, the solution need not be too accurate. In this case, the iterative methods are more suitable and the desired accuracy can be set before the solve step using \b setTolerance(). For all the available functions, please, refer to the documentation of the \link IterativeLinearSolvers_Module Iterative solvers module \endlink.
|
||||
|
||||
\section BenchmarkRoutine
|
||||
Most of the time, all you need is to know how much time it will take to solve your system, and hopefully, what is the most suitable solver. In Eigen, we provide a benchmark routine that can be used for this purpose. It is very easy to use. In the build directory, navigate to bench/spbench and compile the routine by typing \b make \e spbenchsolver. Run it with --help option to get the list of all available options. Basically, the matrices to test should be in <a href="http://math.nist.gov/MatrixMarket/formats.html">MatrixMarket Coordinate format</a>, and the routine returns the statistics from all available solvers in Eigen.
|
||||
Most of the time, all you need is to know how much time it will take to solve your system, and hopefully, what is the most suitable solver. In Eigen, we provide a benchmark routine that can be used for this purpose. It is very easy to use. In the build directory, navigate to `bench/spbench` and compile the routine by typing `make spbenchsolver`. Run it with `--help` option to get the list of all available options. Basically, the matrices to test should be in <a href="http://math.nist.gov/MatrixMarket/formats.html">MatrixMarket Coordinate format</a>, and the routine returns the statistics from all available solvers in Eigen.
|
||||
|
||||
To export your matrices and right-hand-side vectors in the matrix-market format, you can the the unsupported SparseExtra module:
|
||||
\code
|
||||
|
||||
@ -89,7 +89,7 @@ Beyond the basic functions rows() and cols(), there are some useful functions th
|
||||
sm1.nonZeros(); // Number of non zero values
|
||||
sm1.outerSize(); // Number of columns (resp. rows) for a column major (resp. row major )
|
||||
sm1.innerSize(); // Number of rows (resp. columns) for a row major (resp. column major)
|
||||
sm1.norm(); // Euclidian norm of the matrix
|
||||
sm1.norm(); // Euclidean norm of the matrix
|
||||
sm1.squaredNorm(); // Squared norm of the matrix
|
||||
sm1.blueNorm();
|
||||
sm1.isVector(); // Check if sm1 is a sparse vector or a sparse matrix
|
||||
@ -249,7 +249,7 @@ sm1.outerIndexPtr(); // Pointer to the beginning of each inner vector
|
||||
\endcode
|
||||
</td>
|
||||
<td>
|
||||
If the matrix is not in compressed form, makeCompressed() should be called before.\n
|
||||
If the matrix is not in compressed form, `makeCompressed()` should be called before.\n
|
||||
Note that these functions are mostly provided for interoperability purposes with external libraries.\n
|
||||
A better access to the values of the matrix is done by using the InnerIterator class as described in \link TutorialSparse the Tutorial Sparse \endlink section</td>
|
||||
</tr>
|
||||
|
||||
@ -70,9 +70,9 @@ There are other macros derived from EIGEN_STATIC_ASSERT to enhance readability.
|
||||
|
||||
- \b EIGEN_STATIC_ASSERT_FIXED_SIZE(TYPE) - passes if \a TYPE is fixed size.
|
||||
- \b EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE) - passes if \a TYPE is dynamic size.
|
||||
- \b EIGEN_STATIC_ASSERT_LVALUE(Derived) - failes if \a Derived is read-only.
|
||||
- \b EIGEN_STATIC_ASSERT_LVALUE(Derived) - fails if \a Derived is read-only.
|
||||
- \b EIGEN_STATIC_ASSERT_ARRAYXPR(Derived) - passes if \a Derived is an array expression.
|
||||
- <b>EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)</b> - failes if the two expressions are an array one and a matrix one.
|
||||
- <b>EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)</b> - fails if the two expressions are an array one and a matrix one.
|
||||
|
||||
Because Eigen handles both fixed-size and dynamic-size expressions, some conditions cannot be clearly determined at compile time. We classify them into strict assertions and permissive assertions.
|
||||
|
||||
|
||||
@ -272,7 +272,7 @@ To get an overview of the true relative speed of the different decompositions, c
|
||||
<dt><b>Blocking</b></dt>
|
||||
<dd>Means the algorithm can work per block, whence guaranteeing a good scaling of the performance for large matrices.</dd>
|
||||
<dt><b>Implicit Multi Threading (MT)</b></dt>
|
||||
<dd>Means the algorithm can take advantage of multicore processors via OpenMP. "Implicit" means the algortihm itself is not parallelized, but that it relies on parallelized matrix-matrix product routines.</dd>
|
||||
<dd>Means the algorithm can take advantage of multicore processors via OpenMP. "Implicit" means the algorithm itself is not parallelized, but that it relies on parallelized matrix-matrix product routines.</dd>
|
||||
<dt><b>Explicit Multi Threading (MT)</b></dt>
|
||||
<dd>Means the algorithm is explicitly parallelized to take advantage of multicore processors via OpenMP.</dd>
|
||||
<dt><b>Meta-unroller</b></dt>
|
||||
|
||||
@ -7,7 +7,7 @@ In this page, we will introduce the many possibilities offered by the \ref Geome
|
||||
\eigenAutoToc
|
||||
|
||||
Eigen's Geometry module provides two different kinds of geometric transformations:
|
||||
- Abstract transformations, such as rotations (represented by \ref AngleAxis "angle and axis" or by a \ref Quaternion "quaternion"), \ref Translation "translations", \ref Scaling "scalings". These transformations are NOT represented as matrices, but you can nevertheless mix them with matrices and vectors in expressions, and convert them to matrices if you wish.
|
||||
- Abstract transformations, such as rotations (represented by \ref AngleAxis "angle and axis" or by a \ref Quaternion "quaternion"), \ref Translation "translations", \ref Scaling() "scalings". These transformations are NOT represented as matrices, but you can nevertheless mix them with matrices and vectors in expressions, and convert them to matrices if you wish.
|
||||
- Projective or affine transformation matrices: see the Transform class. These are really matrices.
|
||||
|
||||
\note If you are working with OpenGL 4x4 matrices then Affine3f and Affine3d are what you want. Since Eigen defaults to column-major storage, you can directly use the Transform::data() method to pass your transformation matrix to OpenGL.
|
||||
|
||||
@ -10,7 +10,7 @@ between matrices, vectors and scalars with Eigen.
|
||||
\section TutorialArithmeticIntroduction Introduction
|
||||
|
||||
Eigen offers matrix/vector arithmetic operations either through overloads of common C++ arithmetic operators such as +, -, *,
|
||||
or through special methods such as dot(), cross(), etc.
|
||||
or through special methods such as \link MatrixBase::dot() dot()\endlink, \link MatrixBase::cross() cross()\endlink, etc.
|
||||
For the Matrix class (matrices and vectors), operators are only overloaded to support
|
||||
linear-algebraic operations. For example, \c matrix1 \c * \c matrix2 means matrix-matrix product,
|
||||
and \c vector \c + \c scalar is just not allowed. If you want to perform all kinds of array operations,
|
||||
|
||||
@ -151,14 +151,14 @@ The numbering starts at 0. This example is self-explanatory:
|
||||
\verbinclude tut_matrix_coefficient_accessors.out
|
||||
</td></tr></table>
|
||||
|
||||
Note that the syntax <tt> m(index) </tt>
|
||||
Note that the syntax `m(index)`
|
||||
is not restricted to vectors, it is also available for general matrices, meaning index-based access
|
||||
in the array of coefficients. This however depends on the matrix's storage order. All Eigen matrices default to
|
||||
column-major storage order, but this can be changed to row-major, see \ref TopicStorageOrders "Storage orders".
|
||||
|
||||
The operator[] is also overloaded for index-based access in vectors, but keep in mind that C++ doesn't allow operator[] to
|
||||
take more than one argument. We restrict operator[] to vectors, because an awkwardness in the C++ language
|
||||
would make matrix[i,j] compile to the same thing as matrix[j] !
|
||||
The `operator[]` is also overloaded for index-based access in vectors, but keep in mind that C++ doesn't allow `operator[]` to
|
||||
take more than one argument. We restrict `operator[]` to vectors, because an awkwardness in the C++ language
|
||||
would make `matrix[i,j]` compile to the same thing as `matrix[j]`!
|
||||
|
||||
\section TutorialMatrixCommaInitializer Comma-initialization
|
||||
|
||||
@ -186,8 +186,8 @@ The current size of a matrix can be retrieved by \link EigenBase::rows() rows()\
|
||||
<td>\verbinclude tut_matrix_resize.out </td>
|
||||
</tr></table>
|
||||
|
||||
The resize() method is a no-operation if the actual matrix size doesn't change; otherwise it is destructive: the values of the coefficients may change.
|
||||
If you want a conservative variant of resize() which does not change the coefficients, use \link PlainObjectBase::conservativeResize() conservativeResize()\endlink, see \ref TopicResizing "this page" for more details.
|
||||
The `resize()` method is a no-operation if the actual matrix size doesn't change; otherwise it is destructive: the values of the coefficients may change.
|
||||
If you want a conservative variant of `resize()` which does not change the coefficients, use \link PlainObjectBase::conservativeResize() conservativeResize()\endlink, see \ref TopicResizing "this page" for more details.
|
||||
|
||||
All these methods are still available on fixed-size matrices, for the sake of API uniformity. Of course, you can't actually
|
||||
resize a fixed-size matrix. Trying to change a fixed size to an actually different value will trigger an assertion failure;
|
||||
@ -234,7 +234,7 @@ is always allocated on the heap, so doing
|
||||
\code MatrixXf mymatrix(rows,columns); \endcode
|
||||
amounts to doing
|
||||
\code float *mymatrix = new float[rows*columns]; \endcode
|
||||
and in addition to that, the MatrixXf object stores its number of rows and columns as
|
||||
and in addition to that, the \c MatrixXf object stores its number of rows and columns as
|
||||
member variables.
|
||||
|
||||
The limitation of using fixed sizes, of course, is that this is only possible
|
||||
@ -276,14 +276,16 @@ Matrix<typename Scalar,
|
||||
\section TutorialMatrixTypedefs Convenience typedefs
|
||||
|
||||
Eigen defines the following Matrix typedefs:
|
||||
\li MatrixNt for Matrix<type, N, N>. For example, MatrixXi for Matrix<int, Dynamic, Dynamic>.
|
||||
\li VectorNt for Matrix<type, N, 1>. For example, Vector2f for Matrix<float, 2, 1>.
|
||||
\li RowVectorNt for Matrix<type, 1, N>. For example, RowVector3d for Matrix<double, 1, 3>.
|
||||
\li \c MatrixNt for `Matrix<type, N, N>`. For example, \c MatrixXi for `Matrix<int, Dynamic, Dynamic>`.
|
||||
\li \c MatrixXNt for `Matrix<type, Dynamic, N>`. For example, \c MatrixX3i for `Matrix<int, Dynamic, 3>`.
|
||||
\li \c MatrixNXt for `Matrix<type, N, Dynamic>`. For example, \c Matrix4Xd for `Matrix<d, 4, Dynamic>`.
|
||||
\li \c VectorNt for `Matrix<type, N, 1>`. For example, \c Vector2f for `Matrix<float, 2, 1>`.
|
||||
\li \c RowVectorNt for `Matrix<type, 1, N>`. For example, \c RowVector3d for `Matrix<double, 1, 3>`.
|
||||
|
||||
Where:
|
||||
\li N can be any one of \c 2, \c 3, \c 4, or \c X (meaning \c Dynamic).
|
||||
\li t can be any one of \c i (meaning int), \c f (meaning float), \c d (meaning double),
|
||||
\c cf (meaning complex<float>), or \c cd (meaning complex<double>). The fact that typedefs are only
|
||||
\li \c N can be any one of \c 2, \c 3, \c 4, or \c X (meaning \c Dynamic).
|
||||
\li \c t can be any one of \c i (meaning \c int), \c f (meaning \c float), \c d (meaning \c double),
|
||||
\c cf (meaning `complex<float>`), or \c cd (meaning `complex<double>`). The fact that `typedef`s are only
|
||||
defined for these five types doesn't mean that they are the only supported scalar types. For example,
|
||||
all standard integer types are supported, see \ref TopicScalarTypes "Scalar types".
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@ namespace Eigen {
|
||||
/** \eigenManualPage TutorialReshape Reshape
|
||||
|
||||
Since the version 3.4, %Eigen exposes convenient methods to reshape a matrix to another matrix of different sizes or vector.
|
||||
All cases are handled via the DenseBase::reshaped(NRowsType,NColsType) and DenseBase::reshaped() functions.
|
||||
All cases are handled via the `DenseBase::reshaped(NRowsType,NColsType)` and `DenseBase::reshaped()` functions.
|
||||
Those functions do not perform in-place reshaping, but instead return a <i> view </i> on the input expression.
|
||||
|
||||
\eigenAutoToc
|
||||
@ -23,7 +23,7 @@ Here is an example reshaping a 4x4 matrix to a 2x8 one:
|
||||
</td></tr></table>
|
||||
|
||||
By default, the input coefficients are always interpreted in column-major order regardless of the storage order of the input expression.
|
||||
For more control on ordering, compile-time sizes, and automatic size deduction, please see de documentation of DenseBase::reshaped(NRowsType,NColsType) that contains all the details with many examples.
|
||||
For more control on ordering, compile-time sizes, and automatic size deduction, please see de documentation of `DenseBase::reshaped(NRowsType,NColsType)` that contains all the details with many examples.
|
||||
|
||||
|
||||
\section TutorialReshapeMat2Vec 1D linear views
|
||||
|
||||
@ -14,8 +14,8 @@ In particular, it supports \b slicing that consists in taking a set of rows, col
|
||||
All the aforementioned operations are handled through the generic DenseBase::operator()(const RowIndices&, const ColIndices&) method.
|
||||
Each argument can be:
|
||||
- An integer indexing a single row or column, including symbolic indices.
|
||||
- The symbol Eigen::placeholders::all representing the whole set of respective rows or columns in increasing order.
|
||||
- An ArithmeticSequence as constructed by the Eigen::seq, Eigen::seqN, or Eigen::placeholders::lastN functions.
|
||||
- The symbol Eigen::indexing::all representing the whole set of respective rows or columns in increasing order.
|
||||
- An ArithmeticSequence as constructed by the Eigen::seq, Eigen::seqN, or Eigen::indexing::lastN functions.
|
||||
- Any 1D vector/array of integers including %Eigen's vector/array, expressions, std::vector, std::array, as well as plain C arrays: `int[N]`.
|
||||
|
||||
More generally, it can accepts any object exposing the following two member functions:
|
||||
@ -72,12 +72,12 @@ Here are some examples for a 2D array/matrix \c A and a 1D array/vector \c v.
|
||||
</tr>
|
||||
<tr>
|
||||
<td>%Block starting at \c i,j having \c m rows, and \c n columns</td>
|
||||
<td>\code A(seqN(i,m), seqN(i,n)) \endcode</td>
|
||||
<td>\code A(seqN(i,m), seqN(j,n)) \endcode</td>
|
||||
<td>\code A.block(i,j,m,n) \endcode</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>%Block starting at \c i0,j0 and ending at \c i1,j1</td>
|
||||
<td>\code A(seq(i0,i1), seq(j0,j1) \endcode</td>
|
||||
<td>\code A(seq(i0,i1), seq(j0,j1)) \endcode</td>
|
||||
<td>\code A.block(i0,j0,i1-i0+1,j1-j0+1) \endcode</td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -86,18 +86,18 @@ Here are some examples for a 2D array/matrix \c A and a 1D array/vector \c v.
|
||||
<td></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>First \c n odd rows A</td>
|
||||
<td>First \c n odd rows of A</td>
|
||||
<td>\code A(seqN(1,n,2), all) \endcode</td>
|
||||
<td></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The last past one column</td>
|
||||
<td>The second-last column</td>
|
||||
<td>\code A(all, last-1) \endcode</td>
|
||||
<td>\code A.col(A.cols()-2) \endcode</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>The middle row</td>
|
||||
<td>\code A(last/2,all) \endcode</td>
|
||||
<td>\code A(last/2, all) \endcode</td>
|
||||
<td>\code A.row((A.rows()-1)/2) \endcode</td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -112,9 +112,10 @@ Here are some examples for a 2D array/matrix \c A and a 1D array/vector \c v.
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
As seen in the last exemple, referencing the <i> last n </i> elements (or rows/columns) is a bit cumbersome to write.
|
||||
As seen in the last example, referencing the <i> last n </i> elements (or rows/columns) is a bit cumbersome to write.
|
||||
This becomes even more tricky and error prone with a non-default increment.
|
||||
Here comes \link Eigen::lastN(SizeType) Eigen::lastN(size) \endlink, and \link Eigen::lastN(SizeType,IncrType) Eigen::lastN(size,incr) \endlink:
|
||||
Here comes \link indexing_lastN Eigen::indexing::lastN(size) \endlink, and
|
||||
\link indexing_lastN_with_incr Eigen::indexing::lastN(size,incr) \endlink:
|
||||
|
||||
<table class="manual">
|
||||
<tr>
|
||||
@ -157,7 +158,7 @@ It is equivalent to:
|
||||
\endcode
|
||||
|
||||
We can revisit the <i>even columns of A</i> example as follows:
|
||||
\code A(all, seq(0,last,fix<2>))
|
||||
\code A(all, seq(fix<0>,last,fix<2>))
|
||||
\endcode
|
||||
|
||||
|
||||
@ -221,7 +222,7 @@ i = ind[i];
|
||||
\endcode
|
||||
|
||||
This means you can easily build your own fancy sequence generator and pass it to `operator()`.
|
||||
Here is an exemple enlarging a given matrix while padding the additional first rows and columns through repetition:
|
||||
Here is an example enlarging a given matrix while padding the additional first rows and columns through repetition:
|
||||
|
||||
<table class="example">
|
||||
<tr><th>Example:</th><th>Output:</th></tr>
|
||||
|
||||
@ -54,13 +54,13 @@ and one of its possible sparse, \b column \b major representation:
|
||||
|
||||
Currently the elements of a given inner vector are guaranteed to be always sorted by increasing inner indices.
|
||||
The \c "_" indicates available free space to quickly insert new elements.
|
||||
Assuming no reallocation is needed, the insertion of a random element is therefore in O(nnz_j) where nnz_j is the number of nonzeros of the respective inner vector.
|
||||
On the other hand, inserting elements with increasing inner indices in a given inner vector is much more efficient since this only requires to increase the respective \c InnerNNZs entry that is a O(1) operation.
|
||||
Assuming no reallocation is needed, the insertion of a random element is therefore in `O(nnz_j)` where `nnz_j` is the number of nonzeros of the respective inner vector.
|
||||
On the other hand, inserting elements with increasing inner indices in a given inner vector is much more efficient since this only requires to increase the respective \c InnerNNZs entry that is a `O(1)` operation.
|
||||
|
||||
The case where no empty space is available is a special case, and is referred as the \em compressed mode.
|
||||
It corresponds to the widely used Compressed Column (or Row) Storage schemes (CCS or CRS).
|
||||
Any SparseMatrix can be turned to this form by calling the SparseMatrix::makeCompressed() function.
|
||||
In this case, one can remark that the \c InnerNNZs array is redundant with \c OuterStarts because we have the equality: \c InnerNNZs[j] = \c OuterStarts[j+1]-\c OuterStarts[j].
|
||||
In this case, one can remark that the \c InnerNNZs array is redundant with \c OuterStarts because we have the equality: `InnerNNZs[j] == OuterStarts[j+1] - OuterStarts[j]`.
|
||||
Therefore, in practice a call to SparseMatrix::makeCompressed() frees this buffer.
|
||||
|
||||
It is worth noting that most of our wrappers to external libraries requires compressed matrices as inputs.
|
||||
@ -90,9 +90,7 @@ Such problem can be mathematically expressed as a linear problem of the form \f$
|
||||
<tr><td>
|
||||
\include Tutorial_sparse_example.cpp
|
||||
</td>
|
||||
<td>
|
||||
\image html Tutorial_sparse_example.jpeg
|
||||
</td></tr></table>
|
||||
</tr></table>
|
||||
|
||||
In this example, we start by defining a column-major sparse matrix type of double \c SparseMatrix<double>, and a triplet list of the same scalar type \c Triplet<double>. A triplet is a simple object representing a non-zero entry as the triplet: \c row index, \c column index, \c value.
|
||||
|
||||
@ -221,9 +219,9 @@ A typical scenario of this approach is illustrated below:
|
||||
5: mat.makeCompressed(); // optional
|
||||
\endcode
|
||||
|
||||
- The key ingredient here is the line 2 where we reserve room for 6 non-zeros per column. In many cases, the number of non-zeros per column or row can easily be known in advance. If it varies significantly for each inner vector, then it is possible to specify a reserve size for each inner vector by providing a vector object with an operator[](int j) returning the reserve size of the \c j-th inner vector (e.g., via a VectorXi or std::vector<int>). If only a rought estimate of the number of nonzeros per inner-vector can be obtained, it is highly recommended to overestimate it rather than the opposite. If this line is omitted, then the first insertion of a new element will reserve room for 2 elements per inner vector.
|
||||
- The key ingredient here is the line 2 where we reserve room for 6 non-zeros per column. In many cases, the number of non-zeros per column or row can easily be known in advance. If it varies significantly for each inner vector, then it is possible to specify a reserve size for each inner vector by providing a vector object with an `operator[](int j)` returning the reserve size of the \c j-th inner vector (e.g., via a `VectorXi` or `std::vector<int>`). If only a rought estimate of the number of nonzeros per inner-vector can be obtained, it is highly recommended to overestimate it rather than the opposite. If this line is omitted, then the first insertion of a new element will reserve room for 2 elements per inner vector.
|
||||
- The line 4 performs a sorted insertion. In this example, the ideal case is when the \c j-th column is not full and contains non-zeros whose inner-indices are smaller than \c i. In this case, this operation boils down to trivial O(1) operation.
|
||||
- When calling insert(i,j) the element \c i \c ,j must not already exists, otherwise use the coeffRef(i,j) method that will allow to, e.g., accumulate values. This method first performs a binary search and finally calls insert(i,j) if the element does not already exist. It is more flexible than insert() but also more costly.
|
||||
- When calling `insert(i,j)` the element `i`, `j` must not already exists, otherwise use the `coeffRef(i,j)` method that will allow to, e.g., accumulate values. This method first performs a binary search and finally calls `insert(i,j)` if the element does not already exist. It is more flexible than `insert()` but also more costly.
|
||||
- The line 5 suppresses the remaining empty space and transforms the matrix into a compressed column storage.
|
||||
|
||||
|
||||
@ -259,7 +257,7 @@ sm2 = sm1.cwiseProduct(dm1);
|
||||
dm2 = sm1 + dm1;
|
||||
dm2 = dm1 - sm1;
|
||||
\endcode
|
||||
Performance-wise, the adding/subtracting sparse and dense matrices is better performed in two steps. For instance, instead of doing <tt>dm2 = sm1 + dm1</tt>, better write:
|
||||
Performance-wise, the adding/subtracting sparse and dense matrices is better performed in two steps. For instance, instead of doing `dm2 = sm1 + dm1`, better write:
|
||||
\code
|
||||
dm2 = dm1;
|
||||
dm2 += sm1;
|
||||
@ -272,7 +270,7 @@ This version has the advantage to fully exploit the higher performance of dense
|
||||
sm1 = sm2.transpose();
|
||||
sm1 = sm2.adjoint();
|
||||
\endcode
|
||||
However, there is no transposeInPlace() method.
|
||||
However, there is no `transposeInPlace()` method.
|
||||
|
||||
|
||||
\subsection TutorialSparse_Products Matrix products
|
||||
@ -284,18 +282,18 @@ dv2 = sm1 * dv1;
|
||||
dm2 = dm1 * sm1.adjoint();
|
||||
dm2 = 2. * sm1 * dm1;
|
||||
\endcode
|
||||
- \b symmetric \b sparse-dense. The product of a sparse symmetric matrix with a dense matrix (or vector) can also be optimized by specifying the symmetry with selfadjointView():
|
||||
- \b symmetric \b sparse-dense. The product of a sparse symmetric matrix with a dense matrix (or vector) can also be optimized by specifying the symmetry with `selfadjointView()`:
|
||||
\code
|
||||
dm2 = sm1.selfadjointView<>() * dm1; // if all coefficients of A are stored
|
||||
dm2 = A.selfadjointView<Upper>() * dm1; // if only the upper part of A is stored
|
||||
dm2 = A.selfadjointView<Lower>() * dm1; // if only the lower part of A is stored
|
||||
dm2 = sm1.selfadjointView<>() * dm1; // if all coefficients of sm1 are stored
|
||||
dm2 = sm1.selfadjointView<Upper>() * dm1; // if only the upper part of sm1 is stored
|
||||
dm2 = sm1.selfadjointView<Lower>() * dm1; // if only the lower part of sm1 is stored
|
||||
\endcode
|
||||
- \b sparse-sparse. For sparse-sparse products, two different algorithms are available. The default one is conservative and preserve the explicit zeros that might appear:
|
||||
\code
|
||||
sm3 = sm1 * sm2;
|
||||
sm3 = 4 * sm1.adjoint() * sm2;
|
||||
\endcode
|
||||
The second algorithm prunes on the fly the explicit zeros, or the values smaller than a given threshold. It is enabled and controlled through the prune() functions:
|
||||
The second algorithm prunes on the fly the explicit zeros, or the values smaller than a given threshold. It is enabled and controlled through the `prune()` functions:
|
||||
\code
|
||||
sm3 = (sm1 * sm2).pruned(); // removes numerical zeros
|
||||
sm3 = (sm1 * sm2).pruned(ref); // removes elements much smaller than ref
|
||||
@ -314,7 +312,7 @@ sm2 = sm1.transpose() * P;
|
||||
\subsection TutorialSparse_SubMatrices Block operations
|
||||
|
||||
Regarding read-access, sparse matrices expose the same API than for dense matrices to access to sub-matrices such as blocks, columns, and rows. See \ref TutorialBlockOperations for a detailed introduction.
|
||||
However, for performance reasons, writing to a sub-sparse-matrix is much more limited, and currently only contiguous sets of columns (resp. rows) of a column-major (resp. row-major) SparseMatrix are writable. Moreover, this information has to be known at compile-time, leaving out methods such as <tt>block(...)</tt> and <tt>corner*(...)</tt>. The available API for write-access to a SparseMatrix are summarized below:
|
||||
However, for performance reasons, writing to a sub-sparse-matrix is much more limited, and currently only contiguous sets of columns (resp. rows) of a column-major (resp. row-major) SparseMatrix are writable. Moreover, this information has to be known at compile-time, leaving out methods such as `block(...)` and `corner*(...)`. The available API for write-access to a SparseMatrix are summarized below:
|
||||
\code
|
||||
SparseMatrix<double,ColMajor> sm1;
|
||||
sm1.col(j) = ...;
|
||||
@ -329,22 +327,22 @@ sm2.middleRows(i,nrows) = ...;
|
||||
sm2.bottomRows(nrows) = ...;
|
||||
\endcode
|
||||
|
||||
In addition, sparse matrices expose the SparseMatrixBase::innerVector() and SparseMatrixBase::innerVectors() methods, which are aliases to the col/middleCols methods for a column-major storage, and to the row/middleRows methods for a row-major storage.
|
||||
In addition, sparse matrices expose the `SparseMatrixBase::innerVector()` and `SparseMatrixBase::innerVectors()` methods, which are aliases to the `col`/`middleCols` methods for a column-major storage, and to the `row`/`middleRows` methods for a row-major storage.
|
||||
|
||||
\subsection TutorialSparse_TriangularSelfadjoint Triangular and selfadjoint views
|
||||
|
||||
Just as with dense matrices, the triangularView() function can be used to address a triangular part of the matrix, and perform triangular solves with a dense right hand side:
|
||||
Just as with dense matrices, the `triangularView()` function can be used to address a triangular part of the matrix, and perform triangular solves with a dense right hand side:
|
||||
\code
|
||||
dm2 = sm1.triangularView<Lower>(dm1);
|
||||
dv2 = sm1.transpose().triangularView<Upper>(dv1);
|
||||
\endcode
|
||||
|
||||
The selfadjointView() function permits various operations:
|
||||
The `selfadjointView()` function permits various operations:
|
||||
- optimized sparse-dense matrix products:
|
||||
\code
|
||||
dm2 = sm1.selfadjointView<>() * dm1; // if all coefficients of A are stored
|
||||
dm2 = A.selfadjointView<Upper>() * dm1; // if only the upper part of A is stored
|
||||
dm2 = A.selfadjointView<Lower>() * dm1; // if only the lower part of A is stored
|
||||
dm2 = sm1.selfadjointView<>() * dm1; // if all coefficients of sm1 are stored
|
||||
dm2 = sm1.selfadjointView<Upper>() * dm1; // if only the upper part of sm1 is stored
|
||||
dm2 = sm1.selfadjointView<Lower>() * dm1; // if only the lower part of sm1 is stored
|
||||
\endcode
|
||||
- copy of triangular parts:
|
||||
\code
|
||||
|
||||
@ -106,7 +106,7 @@ However there are a few corner cases where these alignment settings get overridd
|
||||
|
||||
Three possibilities:
|
||||
<ul>
|
||||
<li>Use the \c DontAlign option to Matrix, Array, Quaternion, etc. objects that gives you trouble. This way %Eigen won't try to over-align them, and thus won"t assume any special alignment. On the down side, you will pay the cost of unaligned loads/stores for them, but on modern CPUs, the overhead is either null or marginal. See \link StructHavingEigenMembers_othersolutions here \endlink for an example.</li>
|
||||
<li>Use the \c DontAlign option to Matrix, Array, Quaternion, etc. objects that gives you trouble. This way %Eigen won't try to over-align them, and thus won't assume any special alignment. On the down side, you will pay the cost of unaligned loads/stores for them, but on modern CPUs, the overhead is either null or marginal. See \link StructHavingEigenMembers_othersolutions here \endlink for an example.</li>
|
||||
<li>Define \link TopicPreprocessorDirectivesPerformance EIGEN_MAX_STATIC_ALIGN_BYTES \endlink to 0. That disables all 16-byte (and above) static alignment code, while keeping 16-byte (or above) heap alignment. This has the effect of
|
||||
vectorizing fixed-size objects (like Matrix4d) through unaligned stores (as controlled by \link TopicPreprocessorDirectivesPerformance EIGEN_UNALIGNED_VECTORIZE \endlink), while keeping unchanged the vectorization of dynamic-size objects
|
||||
(like MatrixXd). On 64 bytes systems, you might also define it 16 to disable only 32 and 64 bytes of over-alignment. But do note that this breaks ABI compatibility with the default behavior of static alignment.</li>
|
||||
|
||||
@ -160,9 +160,7 @@ div.toc {
|
||||
margin:0;
|
||||
padding: 0.3em 0 0 0;
|
||||
width:100%;
|
||||
float:none;
|
||||
position:absolute;
|
||||
bottom:0;
|
||||
float: none;
|
||||
border-radius:0px;
|
||||
border-style: solid none none none;
|
||||
max-height:50%;
|
||||
|
||||
@ -1,23 +1,18 @@
|
||||
<!-- HTML footer for doxygen 1.13.0-->
|
||||
<!-- start footer part -->
|
||||
<!--BEGIN GENERATE_TREEVIEW-->
|
||||
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
|
||||
<ul>
|
||||
$navpath
|
||||
<li class="footer">$generatedby
|
||||
<a href="http://www.doxygen.org/index.html">
|
||||
<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
|
||||
<li class="footer">$generatedby <a href="https://www.doxygen.org/index.html"><img class="footer" src="$relpath^doxygen.svg" width="104" height="31" alt="doxygen"/></a> $doxygenversion </li>
|
||||
</ul>
|
||||
</div>
|
||||
<!--END GENERATE_TREEVIEW-->
|
||||
<!--BEGIN !GENERATE_TREEVIEW-->
|
||||
<hr class="footer"/><address class="footer"><small>
|
||||
$generatedby  <a href="http://www.doxygen.org/index.html">
|
||||
<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
|
||||
</a> $doxygenversion
|
||||
$generatedby <a href="https://www.doxygen.org/index.html"><img class="footer" src="$relpath^doxygen.svg" width="104" height="31" alt="doxygen"/></a> $doxygenversion
|
||||
</small></address>
|
||||
</div><!-- doc-content -->
|
||||
<!--END !GENERATE_TREEVIEW-->
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
|
||||
@ -1,27 +1,41 @@
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
<!-- HTML header for doxygen 1.13.0-->
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" lang="$langISO">
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=11"/>
|
||||
<meta name="generator" content="Doxygen $doxygenversion"/>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1"/>
|
||||
<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
|
||||
<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
|
||||
<!--BEGIN PROJECT_ICON-->
|
||||
<link rel="icon" href="$relpath^$projecticon" type="image/x-icon" />
|
||||
<!--END PROJECT_ICON-->
|
||||
<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
|
||||
<!--BEGIN DISABLE_INDEX-->
|
||||
<!--BEGIN FULL_SIDEBAR-->
|
||||
<script type="text/javascript">var page_layout=1;</script>
|
||||
<!--END FULL_SIDEBAR-->
|
||||
<!--END DISABLE_INDEX-->
|
||||
<script type="text/javascript" src="$relpath^jquery.js"></script>
|
||||
<script type="text/javascript" src="$relpath^dynsections.js"></script>
|
||||
<!--BEGIN COPY_CLIPBOARD-->
|
||||
<script type="text/javascript" src="$relpath^clipboard.js"></script>
|
||||
<!--END COPY_CLIPBOARD-->
|
||||
$treeview
|
||||
$search
|
||||
$mathjax
|
||||
$darkmode
|
||||
<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
|
||||
<link href="$relpath$eigendoxy.css" rel="stylesheet" type="text/css">
|
||||
<!-- $extrastylesheet -->
|
||||
<script type="text/javascript" src="$relpath$eigen_navtree_hacks.js"></script>
|
||||
|
||||
$extrastylesheet
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<div style="background:#FFDDDD;font-size:120%;text-align:center;margin:0;padding:5px">Please, help us to better know about our user community by answering the following short survey: <a href="https://forms.gle/wpyrxWi18ox9Z5ae9">https://forms.gle/wpyrxWi18ox9Z5ae9</a></div>
|
||||
<!--BEGIN DISABLE_INDEX-->
|
||||
<!--BEGIN FULL_SIDEBAR-->
|
||||
<div id="side-nav" class="ui-resizable side-nav-resizable"><!-- do not remove this div, it is closed by doxygen! -->
|
||||
<!--END FULL_SIDEBAR-->
|
||||
<!--END DISABLE_INDEX-->
|
||||
|
||||
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
|
||||
|
||||
@ -29,12 +43,12 @@ $mathjax
|
||||
<div id="titlearea">
|
||||
<table cellspacing="0" cellpadding="0">
|
||||
<tbody>
|
||||
<tr style="height: 56px;">
|
||||
<tr id="projectrow">
|
||||
<!--BEGIN PROJECT_LOGO-->
|
||||
<td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
|
||||
<td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"$logosize/></td>
|
||||
<!--END PROJECT_LOGO-->
|
||||
<!--BEGIN PROJECT_NAME-->
|
||||
<td id="projectalign" style="padding-left: 0.5em;">
|
||||
<td id="projectalign">
|
||||
<div id="projectname"><a href="http://eigen.tuxfamily.org">$projectname</a>
|
||||
<!--BEGIN PROJECT_NUMBER--> <span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
|
||||
</div>
|
||||
@ -43,20 +57,26 @@ $mathjax
|
||||
<!--END PROJECT_NAME-->
|
||||
<!--BEGIN !PROJECT_NAME-->
|
||||
<!--BEGIN PROJECT_BRIEF-->
|
||||
<td id="projectalign" style="padding-left: 0.5em;">
|
||||
<td>
|
||||
<div id="projectbrief">$projectbrief</div>
|
||||
</td>
|
||||
<!--END PROJECT_BRIEF-->
|
||||
<!--END !PROJECT_NAME-->
|
||||
<!--BEGIN DISABLE_INDEX-->
|
||||
<!--BEGIN SEARCHENGINE-->
|
||||
<td>$searchbox</td>
|
||||
<!--BEGIN !FULL_SIDEBAR-->
|
||||
<td>$searchbox</td>
|
||||
<!--END !FULL_SIDEBAR-->
|
||||
<!--END SEARCHENGINE-->
|
||||
<!--END DISABLE_INDEX-->
|
||||
</tr>
|
||||
<!--BEGIN SEARCHENGINE-->
|
||||
<!--BEGIN FULL_SIDEBAR-->
|
||||
<tr><td colspan="2">$searchbox</td></tr>
|
||||
<!--END FULL_SIDEBAR-->
|
||||
<!--END SEARCHENGINE-->
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<!--END TITLEAREA-->
|
||||
<!-- end header part -->
|
||||
|
||||
|
||||
@ -1,67 +1,103 @@
|
||||
<?xml version="1.0"?>
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<doxygenlayout version="1.0">
|
||||
<!-- Generated by doxygen 1.13.0 -->
|
||||
<!-- Navigation index tabs for HTML output -->
|
||||
<navindex>
|
||||
<tab type="user" url="index.html" title="Overview" />
|
||||
<tab type="user" url="@ref GettingStarted" title="Getting started" />
|
||||
<tab type="modules" visible="yes" title="Chapters" intro=""/>
|
||||
<tab type="mainpage" visible="yes" title=""/>
|
||||
<tab type="classlist" visible="yes" title="" intro=""/>
|
||||
<!-- <tab type="classmembers" visible="yes" title="" intro=""/> -->
|
||||
<tab type="mainpage" visible="no" title="main"/>
|
||||
<tab type="pages" visible="yes" title="" intro=""/>
|
||||
<tab type="topics" visible="yes" title="Chapters" intro=""/>
|
||||
<tab type="modules" visible="yes" title="" intro="">
|
||||
<tab type="modulelist" visible="yes" title="" intro=""/>
|
||||
<tab type="modulemembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="namespaces" visible="no" title="">
|
||||
<tab type="namespacelist" visible="yes" title="" intro=""/>
|
||||
<tab type="namespacemembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="concepts" visible="yes" title="">
|
||||
</tab>
|
||||
<tab type="interfaces" visible="yes" title="">
|
||||
<tab type="interfacelist" visible="yes" title="" intro=""/>
|
||||
<tab type="interfaceindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="interfacehierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="classes" visible="yes" title="">
|
||||
<tab type="classlist" visible="yes" title="" intro=""/>
|
||||
<tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="hierarchy" visible="yes" title="" intro=""/>
|
||||
<tab type="classmembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="structs" visible="yes" title="">
|
||||
<tab type="structlist" visible="yes" title="" intro=""/>
|
||||
<tab type="structindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
</tab>
|
||||
<tab type="exceptions" visible="yes" title="">
|
||||
<tab type="exceptionlist" visible="yes" title="" intro=""/>
|
||||
<tab type="exceptionindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="files" visible="yes" title="">
|
||||
<tab type="filelist" visible="yes" title="" intro=""/>
|
||||
<tab type="globals" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="examples" visible="yes" title="" intro=""/>
|
||||
</navindex>
|
||||
|
||||
<!-- Layout definition for a class page -->
|
||||
<class>
|
||||
<briefdescription visible="no"/>
|
||||
<includes visible="$SHOW_INCLUDE_FILES"/>
|
||||
<detaileddescription title=""/>
|
||||
<includes visible="$SHOW_HEADERFILE"/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<inheritancegraph visible="$CLASS_GRAPH"/>
|
||||
<collaborationgraph visible="$COLLABORATION_GRAPH"/>
|
||||
<allmemberslink visible="yes"/>
|
||||
<memberdecl>
|
||||
<nestedclasses visible="yes" title=""/>
|
||||
<publictypes title=""/>
|
||||
<publicslots title=""/>
|
||||
<signals title=""/>
|
||||
<publicmethods title=""/>
|
||||
<publicstaticmethods title=""/>
|
||||
<publicattributes title=""/>
|
||||
<publicstaticattributes title=""/>
|
||||
<protectedtypes title=""/>
|
||||
<protectedslots title=""/>
|
||||
<protectedmethods title=""/>
|
||||
<protectedstaticmethods title=""/>
|
||||
<protectedattributes title=""/>
|
||||
<protectedstaticattributes title=""/>
|
||||
<packagetypes title=""/>
|
||||
<packagemethods title=""/>
|
||||
<packagestaticmethods title=""/>
|
||||
<packageattributes title=""/>
|
||||
<packagestaticattributes title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
<privatetypes title=""/>
|
||||
<privateslots title=""/>
|
||||
<privatemethods title=""/>
|
||||
<privatestaticmethods title=""/>
|
||||
<privateattributes title=""/>
|
||||
<privatestaticattributes title=""/>
|
||||
<friends title=""/>
|
||||
<related title="" subtitle=""/>
|
||||
<publictypes visible="yes" title=""/>
|
||||
<services visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicmethods visible="yes" title=""/>
|
||||
<publicstaticmethods visible="yes" title=""/>
|
||||
<publicattributes visible="yes" title=""/>
|
||||
<publicstaticattributes visible="yes" title=""/>
|
||||
<protectedtypes visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<protectedmethods visible="yes" title=""/>
|
||||
<protectedstaticmethods visible="yes" title=""/>
|
||||
<protectedattributes visible="yes" title=""/>
|
||||
<protectedstaticattributes visible="yes" title=""/>
|
||||
<packagetypes visible="yes" title=""/>
|
||||
<packagemethods visible="yes" title=""/>
|
||||
<packagestaticmethods visible="yes" title=""/>
|
||||
<packageattributes visible="yes" title=""/>
|
||||
<packagestaticattributes visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<privatetypes visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<privatemethods visible="yes" title=""/>
|
||||
<privatestaticmethods visible="yes" title=""/>
|
||||
<privateattributes visible="yes" title=""/>
|
||||
<privatestaticattributes visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
<related visible="yes" title="" subtitle=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<constructors title=""/>
|
||||
<functions title=""/>
|
||||
<related title=""/>
|
||||
<variables title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<services visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<constructors visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<related visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<allmemberslink visible="yes"/>
|
||||
<usedfiles visible="$SHOW_USED_FILES"/>
|
||||
<authorsection visible="yes"/>
|
||||
</class>
|
||||
@ -71,24 +107,44 @@
|
||||
<briefdescription visible="yes"/>
|
||||
<memberdecl>
|
||||
<nestednamespaces visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<membergroups visible="yes" visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</namespace>
|
||||
|
||||
<!-- Layout definition for a concept page -->
|
||||
<concept>
|
||||
<briefdescription visible="yes"/>
|
||||
<includes visible="$SHOW_HEADERFILE"/>
|
||||
<definition visible="yes" title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<authorsection visible="yes"/>
|
||||
</concept>
|
||||
|
||||
<!-- Layout definition for a file page -->
|
||||
<file>
|
||||
<briefdescription visible="yes"/>
|
||||
@ -97,23 +153,34 @@
|
||||
<includedbygraph visible="$INCLUDED_BY_GRAPH"/>
|
||||
<sourcelink visible="yes"/>
|
||||
<memberdecl>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<membergroups visible="yes" visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection/>
|
||||
</file>
|
||||
@ -121,50 +188,74 @@
|
||||
<!-- Layout definition for a group page -->
|
||||
<group>
|
||||
<briefdescription visible="no"/>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<groupgraph visible="$GROUP_GRAPHS"/>
|
||||
<memberdecl>
|
||||
<nestedgroups visible="yes" title=""/>
|
||||
<modules visible="yes" title=""/>
|
||||
<dirs visible="yes" title=""/>
|
||||
<files visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<enumvalues visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
|
||||
<memberdef>
|
||||
<pagedocs/>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<enumvalues visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</group>
|
||||
|
||||
<!-- Layout definition for a C++20 module page -->
|
||||
<module>
|
||||
<briefdescription visible="yes"/>
|
||||
<exportedmodules visible="yes"/>
|
||||
<memberdecl>
|
||||
<concepts visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<membergroups visible="yes" title=""/>
|
||||
</memberdecl>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdecl>
|
||||
<files visible="yes"/>
|
||||
</memberdecl>
|
||||
</module>
|
||||
|
||||
<!-- Layout definition for a directory page -->
|
||||
<directory>
|
||||
<briefdescription visible="yes"/>
|
||||
@ -173,6 +264,6 @@
|
||||
<dirs visible="yes"/>
|
||||
<files visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
</directory>
|
||||
</doxygenlayout>
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
#include "src/util/CXX11Meta.h"
|
||||
|
||||
/** \defgroup CXX11_TensorSymmetry_Module Tensor Symmetry Module
|
||||
/** \defgroup TensorSymmetry_Module Tensor Symmetry Module
|
||||
*
|
||||
* This module provides a classes that allow for the definition of
|
||||
* symmetries w.r.t. tensor indices.
|
||||
|
||||
@ -91,7 +91,7 @@ See Assigning to a TensorRef below.
|
||||
|
||||
## Accessing Tensor Elements
|
||||
|
||||
#### <data_type> tensor(index0, index1...)
|
||||
#### data_type tensor(index0, index1...)
|
||||
|
||||
Return the element at position `(index0, index1...)` in tensor
|
||||
`tensor`. You must pass as many parameters as the rank of `tensor`.
|
||||
@ -470,7 +470,7 @@ Represents the datatype of individual tensor elements. For example, for a
|
||||
`Tensor<float>`, `Scalar` is the type `float`. See
|
||||
`setConstant()`.
|
||||
|
||||
#### <Operation>
|
||||
#### (Operation)
|
||||
|
||||
We use this pseudo type to indicate that a tensor Operation is returned by a
|
||||
method. We indicate in the text the type and dimensions of the tensor that the
|
||||
@ -776,7 +776,7 @@ The chain of Operation is evaluated lazily, typically when it is assigned to a
|
||||
tensor. See "Controlling when Expression are Evaluated" for more details about
|
||||
their evaluation.
|
||||
|
||||
### <Operation> constant(const Scalar& val)
|
||||
### (Operation) constant(const Scalar& val)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor but
|
||||
where all elements have the value `val`.
|
||||
@ -804,7 +804,7 @@ tensor, or multiply every element of a tensor by a scalar.
|
||||
0.6 0.6 0.6
|
||||
0.6 0.6 0.6
|
||||
|
||||
### <Operation> random()
|
||||
### (Operation) random()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the current tensor
|
||||
but where all elements have random values.
|
||||
@ -834,7 +834,7 @@ All these operations take a single input tensor as argument and return a tensor
|
||||
of the same type and dimensions as the tensor to which they are applied. The
|
||||
requested operations are applied to each element independently.
|
||||
|
||||
### <Operation> operator-()
|
||||
### (Operation) operator-()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the opposite values of the original tensor.
|
||||
@ -853,42 +853,42 @@ containing the opposite values of the original tensor.
|
||||
-1 -1 -1
|
||||
-1 -1 -1
|
||||
|
||||
### <Operation> sqrt()
|
||||
### (Operation) sqrt()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the square roots of the original tensor.
|
||||
|
||||
### <Operation> rsqrt()
|
||||
### (Operation) rsqrt()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the inverse square roots of the original tensor.
|
||||
|
||||
### <Operation> square()
|
||||
### (Operation) square()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the squares of the original tensor values.
|
||||
|
||||
### <Operation> inverse()
|
||||
### (Operation) inverse()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the inverse of the original tensor values.
|
||||
|
||||
### <Operation> exp()
|
||||
### (Operation) exp()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the exponential of the original tensor.
|
||||
|
||||
### <Operation> log()
|
||||
### (Operation) log()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the natural logarithms of the original tensor.
|
||||
|
||||
### <Operation> abs()
|
||||
### (Operation) abs()
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the absolute values of the original tensor.
|
||||
|
||||
### <Operation> pow(Scalar exponent)
|
||||
### (Operation) pow(Scalar exponent)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the original tensor
|
||||
containing the coefficients of the original tensor to the power of the
|
||||
@ -915,17 +915,17 @@ cubic roots of an int Tensor:
|
||||
0 1 2
|
||||
3 4 5
|
||||
|
||||
### <Operation> operator * (Scalar scale)
|
||||
### (Operation) operator * (Scalar scale)
|
||||
|
||||
Multiplies all the coefficients of the input tensor by the provided scale.
|
||||
|
||||
### <Operation> cwiseMax(Scalar threshold)
|
||||
### (Operation) cwiseMax(Scalar threshold)
|
||||
TODO
|
||||
|
||||
### <Operation> cwiseMin(Scalar threshold)
|
||||
### (Operation) cwiseMin(Scalar threshold)
|
||||
TODO
|
||||
|
||||
### <Operation> unaryExpr(const CustomUnaryOp& func)
|
||||
### (Operation) unaryExpr(const CustomUnaryOp& func)
|
||||
TODO
|
||||
|
||||
|
||||
@ -937,39 +937,39 @@ dimensions as the tensors to which they are applied, and unless otherwise
|
||||
specified it is also of the same type. The requested operations are applied to
|
||||
each pair of elements independently.
|
||||
|
||||
### <Operation> operator+(const OtherDerived& other)
|
||||
### (Operation) operator+(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise sums of the inputs.
|
||||
|
||||
### <Operation> operator-(const OtherDerived& other)
|
||||
### (Operation) operator-(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise differences of the inputs.
|
||||
|
||||
### <Operation> operator*(const OtherDerived& other)
|
||||
### (Operation) operator*(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise products of the inputs.
|
||||
|
||||
### <Operation> operator/(const OtherDerived& other)
|
||||
### (Operation) operator/(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise quotients of the inputs.
|
||||
|
||||
This operator is not supported for integer types.
|
||||
|
||||
### <Operation> cwiseMax(const OtherDerived& other)
|
||||
### (Operation) cwiseMax(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise maximums of the inputs.
|
||||
|
||||
### <Operation> cwiseMin(const OtherDerived& other)
|
||||
### (Operation) cwiseMin(const OtherDerived& other)
|
||||
|
||||
Returns a tensor of the same type and dimensions as the input tensors
|
||||
containing the coefficient wise mimimums of the inputs.
|
||||
|
||||
### <Operation> Logical operators
|
||||
### (Operation) Logical operators
|
||||
|
||||
The following logical operators are supported as well:
|
||||
|
||||
@ -1127,50 +1127,50 @@ scalar, represented as a zero-dimension tensor.
|
||||
276
|
||||
|
||||
|
||||
### <Operation> sum(const Dimensions& new_dims)
|
||||
### <Operation> sum()
|
||||
### (Operation) sum(const Dimensions& new_dims)
|
||||
### (Operation) sum()
|
||||
|
||||
Reduce a tensor using the sum() operator. The resulting values
|
||||
are the sum of the reduced values.
|
||||
|
||||
### <Operation> mean(const Dimensions& new_dims)
|
||||
### <Operation> mean()
|
||||
### (Operation) mean(const Dimensions& new_dims)
|
||||
### (Operation) mean()
|
||||
|
||||
Reduce a tensor using the mean() operator. The resulting values
|
||||
are the mean of the reduced values.
|
||||
|
||||
### <Operation> maximum(const Dimensions& new_dims)
|
||||
### <Operation> maximum()
|
||||
### (Operation) maximum(const Dimensions& new_dims)
|
||||
### (Operation) maximum()
|
||||
|
||||
Reduce a tensor using the maximum() operator. The resulting values are the
|
||||
largest of the reduced values.
|
||||
|
||||
### <Operation> minimum(const Dimensions& new_dims)
|
||||
### <Operation> minimum()
|
||||
### (Operation) minimum(const Dimensions& new_dims)
|
||||
### (Operation) minimum()
|
||||
|
||||
Reduce a tensor using the minimum() operator. The resulting values
|
||||
are the smallest of the reduced values.
|
||||
|
||||
### <Operation> prod(const Dimensions& new_dims)
|
||||
### <Operation> prod()
|
||||
### (Operation) prod(const Dimensions& new_dims)
|
||||
### (Operation) prod()
|
||||
|
||||
Reduce a tensor using the prod() operator. The resulting values
|
||||
are the product of the reduced values.
|
||||
|
||||
### <Operation> all(const Dimensions& new_dims)
|
||||
### <Operation> all()
|
||||
### (Operation) all(const Dimensions& new_dims)
|
||||
### (Operation) all()
|
||||
Reduce a tensor using the all() operator. Casts tensor to bool and then checks
|
||||
whether all elements are true. Runs through all elements rather than
|
||||
short-circuiting, so may be significantly inefficient.
|
||||
|
||||
### <Operation> any(const Dimensions& new_dims)
|
||||
### <Operation> any()
|
||||
### (Operation) any(const Dimensions& new_dims)
|
||||
### (Operation) any()
|
||||
Reduce a tensor using the any() operator. Casts tensor to bool and then checks
|
||||
whether any element is true. Runs through all elements rather than
|
||||
short-circuiting, so may be significantly inefficient.
|
||||
|
||||
|
||||
### <Operation> reduce(const Dimensions& new_dims, const Reducer& reducer)
|
||||
### (Operation) reduce(const Dimensions& new_dims, const Reducer& reducer)
|
||||
|
||||
Reduce a tensor using a user-defined reduction operator. See `SumReducer`
|
||||
in TensorFunctors.h for information on how to implement a reduction operator.
|
||||
@ -1206,8 +1206,8 @@ Example: Trace along 2 dimensions.
|
||||
15
|
||||
|
||||
|
||||
### <Operation> trace(const Dimensions& new_dims)
|
||||
### <Operation> trace()
|
||||
### (Operation) trace(const Dimensions& new_dims)
|
||||
### (Operation) trace()
|
||||
|
||||
As a special case, if no parameter is passed to the operation, trace is computed
|
||||
along *all* dimensions of the input tensor.
|
||||
@ -1257,18 +1257,18 @@ dd a comment to this line
|
||||
1 3 6
|
||||
4 9 15
|
||||
|
||||
### <Operation> cumsum(const Index& axis)
|
||||
### (Operation) cumsum(const Index& axis)
|
||||
|
||||
Perform a scan by summing consecutive entries.
|
||||
|
||||
### <Operation> cumprod(const Index& axis)
|
||||
### (Operation) cumprod(const Index& axis)
|
||||
|
||||
Perform a scan by multiplying consecutive entries.
|
||||
|
||||
|
||||
## Convolutions
|
||||
|
||||
### <Operation> convolve(const Kernel& kernel, const Dimensions& dims)
|
||||
### (Operation) convolve(const Kernel& kernel, const Dimensions& dims)
|
||||
|
||||
Returns a tensor that is the output of the convolution of the input tensor with the kernel,
|
||||
along the specified dimensions of the input tensor. The dimension size for dimensions of the output tensor
|
||||
@ -1311,7 +1311,7 @@ These operations return a Tensor with different dimensions than the original
|
||||
Tensor. They can be used to access slices of tensors, see them with different
|
||||
dimensions, or pad tensors with additional data.
|
||||
|
||||
### <Operation> reshape(const Dimensions& new_dims)
|
||||
### (Operation) reshape(const Dimensions& new_dims)
|
||||
|
||||
Returns a view of the input tensor that has been reshaped to the specified
|
||||
new dimensions. The argument new_dims is an array of Index values. The
|
||||
@ -1390,7 +1390,7 @@ Note that "b" itself was not reshaped but that instead the assignment is done to
|
||||
the reshape view of b.
|
||||
|
||||
|
||||
### <Operation> shuffle(const Shuffle& shuffle)
|
||||
### (Operation) shuffle(const Shuffle& shuffle)
|
||||
|
||||
Returns a copy of the input tensor whose dimensions have been
|
||||
reordered according to the specified permutation. The argument shuffle
|
||||
@ -1431,7 +1431,7 @@ Let's rewrite the previous example to take advantage of this feature:
|
||||
output.shuffle({2, 0, 1}) = input;
|
||||
|
||||
|
||||
### <Operation> stride(const Strides& strides)
|
||||
### (Operation) stride(const Strides& strides)
|
||||
|
||||
Returns a view of the input tensor that strides (skips stride-1
|
||||
elements) along each of the dimensions. The argument strides is an
|
||||
@ -1457,7 +1457,7 @@ It is possible to assign a tensor to a stride:
|
||||
output.stride({2, 3, 4}) = input;
|
||||
|
||||
|
||||
### <Operation> slice(const StartIndices& offsets, const Sizes& extents)
|
||||
### (Operation) slice(const StartIndices& offsets, const Sizes& extents)
|
||||
|
||||
Returns a sub-tensor of the given tensor. For each dimension i, the slice is
|
||||
made of the coefficients stored between offset[i] and offset[i] + extents[i] in
|
||||
@ -1483,7 +1483,7 @@ the input tensor.
|
||||
600 700
|
||||
|
||||
|
||||
### <Operation> chip(const Index offset, const Index dim)
|
||||
### (Operation) chip(const Index offset, const Index dim)
|
||||
|
||||
A chip is a special kind of slice. It is the subtensor at the given offset in
|
||||
the dimension dim. The returned tensor has one fewer dimension than the input
|
||||
@ -1534,7 +1534,7 @@ lvalue. For example:
|
||||
0 0 0
|
||||
|
||||
|
||||
### <Operation> reverse(const ReverseDimensions& reverse)
|
||||
### (Operation) reverse(const ReverseDimensions& reverse)
|
||||
|
||||
Returns a view of the input tensor that reverses the order of the coefficients
|
||||
along a subset of the dimensions. The argument reverse is an array of boolean
|
||||
@ -1564,7 +1564,7 @@ of a 2D tensor:
|
||||
0 100 200
|
||||
|
||||
|
||||
### <Operation> broadcast(const Broadcast& broadcast)
|
||||
### (Operation) broadcast(const Broadcast& broadcast)
|
||||
|
||||
Returns a view of the input tensor in which the input is replicated one to many
|
||||
times.
|
||||
@ -1588,11 +1588,11 @@ made in each of the dimensions.
|
||||
0 100 200 0 100 200
|
||||
300 400 500 300 400 500
|
||||
|
||||
### <Operation> concatenate(const OtherDerived& other, Axis axis)
|
||||
### (Operation) concatenate(const OtherDerived& other, Axis axis)
|
||||
|
||||
TODO
|
||||
|
||||
### <Operation> pad(const PaddingDimensions& padding)
|
||||
### (Operation) pad(const PaddingDimensions& padding)
|
||||
|
||||
Returns a view of the input tensor in which the input is padded with zeros.
|
||||
|
||||
@ -1617,7 +1617,7 @@ Returns a view of the input tensor in which the input is padded with zeros.
|
||||
0 0 0 0
|
||||
|
||||
|
||||
### <Operation> extract_patches(const PatchDims& patch_dims)
|
||||
### (Operation) extract_patches(const PatchDims& patch_dims)
|
||||
|
||||
Returns a tensor of coefficient patches extracted from the input tensor, where
|
||||
each patch is of dimension specified by 'patch_dims'. The returned tensor has
|
||||
@ -1704,7 +1704,7 @@ This code results in the following output when the data layout is RowMajor:
|
||||
6 7
|
||||
10 11
|
||||
|
||||
### <Operation> extract_image_patches(const Index patch_rows, const Index patch_cols, const Index row_stride, const Index col_stride, const PaddingType padding_type)
|
||||
### (Operation) extract_image_patches(const Index patch_rows, const Index patch_cols, const Index row_stride, const Index col_stride, const PaddingType padding_type)
|
||||
|
||||
Returns a tensor of coefficient image patches extracted from the input tensor,
|
||||
which is expected to have dimensions ordered as follows (depending on the data
|
||||
@ -1761,7 +1761,7 @@ sizes:
|
||||
|
||||
## Special Operations
|
||||
|
||||
### <Operation> cast<T>()
|
||||
### (Operation) cast<T>()
|
||||
|
||||
Returns a tensor of type T with the same dimensions as the original tensor.
|
||||
The returned tensor contains the values of the original tensor converted to
|
||||
@ -1790,7 +1790,7 @@ but you can easily cast the tensors to floats to do the division:
|
||||
1 2 2
|
||||
|
||||
|
||||
### <Operation> eval()
|
||||
### (Operation) eval()
|
||||
|
||||
TODO
|
||||
|
||||
|
||||
@ -424,7 +424,7 @@ struct ThreadProperties {
|
||||
* \tparam input_mapper_properties : determine if the input tensors are matrix. If they are matrix, special memory
|
||||
access is used to guarantee that always the memory access are coalesced.
|
||||
*
|
||||
* \tptaram IsFinal : determine if this is the final kernel. If so, the result will be written in a final output.
|
||||
* \tparam IsFinal : determine if this is the final kernel. If so, the result will be written in a final output.
|
||||
Otherwise, the result of contraction will be written iin a temporary buffer. This is the case when Tall/Skinny
|
||||
contraction is used. So in this case, a final reduction step is required to compute final output.
|
||||
|
||||
|
||||
@ -106,7 +106,7 @@ namespace group_theory {
|
||||
/** \internal
|
||||
*
|
||||
* \class strip_identities
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Cleanse a list of group elements of the identity element
|
||||
*
|
||||
@ -148,7 +148,7 @@ struct strip_identities<Equality, id, type_list<EIGEN_TPL_PP_SPEC_HACK_USE(ts)>>
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_first_step_elements_helper
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Recursive template that adds powers of the first generator to the list of group elements
|
||||
*
|
||||
@ -198,7 +198,7 @@ struct dimino_first_step_elements_helper<Multiply, Equality, id, g, current_elem
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_first_step_elements
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Add all powers of the first generator to the list of group elements
|
||||
*
|
||||
@ -236,7 +236,7 @@ struct dimino_first_step_elements
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_get_coset_elements
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Generate all elements of a specific coset
|
||||
*
|
||||
@ -277,7 +277,7 @@ struct dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, fa
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_add_cosets_for_rep
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Recursive template for adding coset spaces
|
||||
*
|
||||
@ -365,7 +365,7 @@ struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, ele
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_add_all_coset_spaces
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Recursive template for adding all coset spaces for a new generator
|
||||
*
|
||||
@ -440,7 +440,7 @@ struct dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, e
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_add_generator
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Enlarge the group by adding a new generator.
|
||||
*
|
||||
@ -502,7 +502,7 @@ struct dimino_add_generator<Multiply, Equality, id, elements, generators_done, c
|
||||
/** \internal
|
||||
*
|
||||
* \class dimino_add_remaining_generators
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Recursive template that adds all remaining generators to a group
|
||||
*
|
||||
@ -570,7 +570,7 @@ struct dimino_add_remaining_generators<Multiply, Equality, id, generators_done,
|
||||
/** \internal
|
||||
*
|
||||
* \class enumerate_group_elements_noid
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Helper template that implements group element enumeration
|
||||
*
|
||||
@ -625,7 +625,7 @@ struct enumerate_group_elements_noid<Multiply, Equality, id, type_list<>, initia
|
||||
/** \internal
|
||||
*
|
||||
* \class enumerate_group_elements
|
||||
* \ingroup CXX11_TensorSymmetry_Module
|
||||
* \ingroup TensorSymmetry_Module
|
||||
*
|
||||
* \brief Enumerate all elements in a finite group
|
||||
*
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
namespace Eigen {
|
||||
|
||||
/** \class MaxSizeVector
|
||||
* \ingroup Core
|
||||
* \ingroup Core_Module
|
||||
*
|
||||
* \brief The MaxSizeVector class.
|
||||
*
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
|
||||
/**
|
||||
* \defgroup IterativeLinearSolvers_Module Iterative solvers module
|
||||
* \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
|
||||
* This module aims to provide various iterative linear and non linear solver algorithms.
|
||||
* It currently provides:
|
||||
* - a constrained conjugate gradient
|
||||
|
||||
@ -299,6 +299,7 @@ namespace Eigen
|
||||
|
||||
#define EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(AXES, SCALAR_TYPE, SCALAR_POSTFIX) \
|
||||
/** \ingroup EulerAngles_Module */ \
|
||||
/** \brief \noop */ \
|
||||
typedef EulerAngles<SCALAR_TYPE, EulerSystem##AXES> EulerAngles##AXES##SCALAR_POSTFIX;
|
||||
|
||||
#define EIGEN_EULER_ANGLES_TYPEDEFS(SCALAR_TYPE, SCALAR_POSTFIX) \
|
||||
|
||||
@ -284,6 +284,7 @@ namespace Eigen
|
||||
|
||||
#define EIGEN_EULER_SYSTEM_TYPEDEF(A, B, C) \
|
||||
/** \ingroup EulerAngles_Module */ \
|
||||
/** \brief \noop */ \
|
||||
typedef EulerSystem<EULER_##A, EULER_##B, EULER_##C> EulerSystem##A##B##C;
|
||||
|
||||
EIGEN_EULER_SYSTEM_TYPEDEF(X,Y,Z)
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
namespace Eigen {
|
||||
|
||||
/**
|
||||
* \ingroup IterativeSolvers_Module
|
||||
* \ingroup IterativeLinearSolvers_Module
|
||||
* \brief iterative scaling algorithm to equilibrate rows and column norms in matrices
|
||||
*
|
||||
* This class can be used as a preprocessing tool to accelerate the convergence of iterative methods
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/// \brief Namespace containing all symbols from the %Eigen library.
|
||||
namespace Eigen {
|
||||
|
||||
/** \mainpage %Eigen's unsupported modules
|
||||
/** \mainpage notitle
|
||||
|
||||
This is the API documentation for %Eigen's unsupported modules.
|
||||
|
||||
|
||||
@ -1,66 +1,103 @@
|
||||
<?xml version="1.0"?>
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<doxygenlayout version="1.0">
|
||||
<!-- Generated by doxygen 1.13.0 -->
|
||||
<!-- Navigation index tabs for HTML output -->
|
||||
<navindex>
|
||||
<tab type="user" url="index.html" title="Overview" />
|
||||
<tab type="modules" visible="yes" title="Unsupported Modules" intro=""/>
|
||||
<!-- <tab type="mainpage" visible="yes" title=""/> -->
|
||||
<tab type="classlist" visible="yes" title="" intro=""/>
|
||||
<!-- <tab type="classmembers" visible="yes" title="" intro=""/> -->
|
||||
<tab type="mainpage" visible="no" title="main"/>
|
||||
<tab type="pages" visible="yes" title="" intro=""/>
|
||||
<tab type="topics" visible="yes" title="Chapters" intro=""/>
|
||||
<tab type="modules" visible="yes" title="" intro="">
|
||||
<tab type="modulelist" visible="yes" title="" intro=""/>
|
||||
<tab type="modulemembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="namespaces" visible="no" title="">
|
||||
<tab type="namespacelist" visible="yes" title="" intro=""/>
|
||||
<tab type="namespacemembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="concepts" visible="yes" title="">
|
||||
</tab>
|
||||
<tab type="interfaces" visible="yes" title="">
|
||||
<tab type="interfacelist" visible="yes" title="" intro=""/>
|
||||
<tab type="interfaceindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="interfacehierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="classes" visible="yes" title="">
|
||||
<tab type="classlist" visible="yes" title="" intro=""/>
|
||||
<tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="hierarchy" visible="yes" title="" intro=""/>
|
||||
<tab type="classmembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="structs" visible="yes" title="">
|
||||
<tab type="structlist" visible="yes" title="" intro=""/>
|
||||
<tab type="structindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
</tab>
|
||||
<tab type="exceptions" visible="yes" title="">
|
||||
<tab type="exceptionlist" visible="yes" title="" intro=""/>
|
||||
<tab type="exceptionindex" visible="$ALPHABETICAL_INDEX" title=""/>
|
||||
<tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="files" visible="yes" title="">
|
||||
<tab type="filelist" visible="yes" title="" intro=""/>
|
||||
<tab type="globals" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="examples" visible="yes" title="" intro=""/>
|
||||
</navindex>
|
||||
|
||||
<!-- Layout definition for a class page -->
|
||||
<class>
|
||||
<briefdescription visible="no"/>
|
||||
<includes visible="$SHOW_INCLUDE_FILES"/>
|
||||
<detaileddescription title=""/>
|
||||
<includes visible="$SHOW_HEADERFILE"/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<inheritancegraph visible="$CLASS_GRAPH"/>
|
||||
<collaborationgraph visible="$COLLABORATION_GRAPH"/>
|
||||
<allmemberslink visible="yes"/>
|
||||
<memberdecl>
|
||||
<nestedclasses visible="yes" title=""/>
|
||||
<publictypes title=""/>
|
||||
<publicslots title=""/>
|
||||
<signals title=""/>
|
||||
<publicmethods title=""/>
|
||||
<publicstaticmethods title=""/>
|
||||
<publicattributes title=""/>
|
||||
<publicstaticattributes title=""/>
|
||||
<protectedtypes title=""/>
|
||||
<protectedslots title=""/>
|
||||
<protectedmethods title=""/>
|
||||
<protectedstaticmethods title=""/>
|
||||
<protectedattributes title=""/>
|
||||
<protectedstaticattributes title=""/>
|
||||
<packagetypes title=""/>
|
||||
<packagemethods title=""/>
|
||||
<packagestaticmethods title=""/>
|
||||
<packageattributes title=""/>
|
||||
<packagestaticattributes title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
<privatetypes title=""/>
|
||||
<privateslots title=""/>
|
||||
<privatemethods title=""/>
|
||||
<privatestaticmethods title=""/>
|
||||
<privateattributes title=""/>
|
||||
<privatestaticattributes title=""/>
|
||||
<friends title=""/>
|
||||
<related title="" subtitle=""/>
|
||||
<publictypes visible="yes" title=""/>
|
||||
<services visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicmethods visible="yes" title=""/>
|
||||
<publicstaticmethods visible="yes" title=""/>
|
||||
<publicattributes visible="yes" title=""/>
|
||||
<publicstaticattributes visible="yes" title=""/>
|
||||
<protectedtypes visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<protectedmethods visible="yes" title=""/>
|
||||
<protectedstaticmethods visible="yes" title=""/>
|
||||
<protectedattributes visible="yes" title=""/>
|
||||
<protectedstaticattributes visible="yes" title=""/>
|
||||
<packagetypes visible="yes" title=""/>
|
||||
<packagemethods visible="yes" title=""/>
|
||||
<packagestaticmethods visible="yes" title=""/>
|
||||
<packageattributes visible="yes" title=""/>
|
||||
<packagestaticattributes visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<privatetypes visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<privatemethods visible="yes" title=""/>
|
||||
<privatestaticmethods visible="yes" title=""/>
|
||||
<privateattributes visible="yes" title=""/>
|
||||
<privatestaticattributes visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
<related visible="yes" title="" subtitle=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<constructors title=""/>
|
||||
<functions title=""/>
|
||||
<related title=""/>
|
||||
<variables title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<services visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<constructors visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<related visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<allmemberslink visible="yes"/>
|
||||
<usedfiles visible="$SHOW_USED_FILES"/>
|
||||
<authorsection visible="yes"/>
|
||||
</class>
|
||||
@ -70,24 +107,44 @@
|
||||
<briefdescription visible="yes"/>
|
||||
<memberdecl>
|
||||
<nestednamespaces visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<membergroups visible="yes" visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</namespace>
|
||||
|
||||
<!-- Layout definition for a concept page -->
|
||||
<concept>
|
||||
<briefdescription visible="yes"/>
|
||||
<includes visible="$SHOW_HEADERFILE"/>
|
||||
<definition visible="yes" title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<authorsection visible="yes"/>
|
||||
</concept>
|
||||
|
||||
<!-- Layout definition for a file page -->
|
||||
<file>
|
||||
<briefdescription visible="yes"/>
|
||||
@ -96,23 +153,34 @@
|
||||
<includedbygraph visible="$INCLUDED_BY_GRAPH"/>
|
||||
<sourcelink visible="yes"/>
|
||||
<memberdecl>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<membergroups visible="yes" visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection/>
|
||||
</file>
|
||||
@ -120,50 +188,74 @@
|
||||
<!-- Layout definition for a group page -->
|
||||
<group>
|
||||
<briefdescription visible="no"/>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<groupgraph visible="$GROUP_GRAPHS"/>
|
||||
<memberdecl>
|
||||
<nestedgroups visible="yes" title=""/>
|
||||
<modules visible="yes" title=""/>
|
||||
<dirs visible="yes" title=""/>
|
||||
<files visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<concepts visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<enumvalues visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
|
||||
<memberdef>
|
||||
<pagedocs/>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
<inlineclasses visible="yes" title=""/>
|
||||
<defines visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<sequences visible="yes" title=""/>
|
||||
<dictionaries visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<enumvalues visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<signals visible="yes" title=""/>
|
||||
<publicslots visible="yes" title=""/>
|
||||
<protectedslots visible="yes" title=""/>
|
||||
<privateslots visible="yes" title=""/>
|
||||
<events visible="yes" title=""/>
|
||||
<properties visible="yes" title=""/>
|
||||
<friends visible="yes" title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</group>
|
||||
|
||||
<!-- Layout definition for a C++20 module page -->
|
||||
<module>
|
||||
<briefdescription visible="yes"/>
|
||||
<exportedmodules visible="yes"/>
|
||||
<memberdecl>
|
||||
<concepts visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<enums visible="yes" title=""/>
|
||||
<typedefs visible="yes" title=""/>
|
||||
<functions visible="yes" title=""/>
|
||||
<variables visible="yes" title=""/>
|
||||
<membergroups visible="yes" title=""/>
|
||||
</memberdecl>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
<memberdecl>
|
||||
<files visible="yes"/>
|
||||
</memberdecl>
|
||||
</module>
|
||||
|
||||
<!-- Layout definition for a directory page -->
|
||||
<directory>
|
||||
<briefdescription visible="yes"/>
|
||||
@ -172,6 +264,6 @@
|
||||
<dirs visible="yes"/>
|
||||
<files visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<detaileddescription visible="yes" title=""/>
|
||||
</directory>
|
||||
</doxygenlayout>
|
||||
|
||||
@ -2,14 +2,13 @@ file(GLOB examples_SRCS "*.cpp")
|
||||
|
||||
add_custom_target(unsupported_examples)
|
||||
|
||||
include_directories(../../../unsupported ../../../unsupported/test)
|
||||
|
||||
foreach(example_src ${examples_SRCS})
|
||||
get_filename_component(example ${example_src} NAME_WE)
|
||||
add_executable(example_${example} ${example_src})
|
||||
if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
|
||||
target_link_libraries(example_${example} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
|
||||
endif()
|
||||
target_link_libraries(example_${example} Eigen3::Eigen)
|
||||
add_custom_command(
|
||||
TARGET example_${example}
|
||||
POST_BUILD
|
||||
|
||||
@ -2,16 +2,11 @@ FILE(GLOB examples_SRCS "*.cpp")
|
||||
|
||||
set(EIGEN_SYCL ON)
|
||||
list(APPEND CMAKE_EXE_LINKER_FLAGS -pthread)
|
||||
if(EIGEN_SYCL_TRISYCL)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
else(EIGEN_SYCL_TRISYCL)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
if(EIGEN_SYCL_ComputeCpp)
|
||||
if(MSVC)
|
||||
# Set the host and device compilers C++ standard to C++14. On Windows setting this to C++11
|
||||
# can cause issues with the ComputeCpp device compiler parsing Visual Studio Headers.
|
||||
set(CMAKE_CXX_STANDARD 14)
|
||||
list(APPEND COMPUTECPP_USER_FLAGS -DWIN32)
|
||||
else()
|
||||
set(CMAKE_CXX_STANDARD 11)
|
||||
list(APPEND COMPUTECPP_USER_FLAGS -Wall)
|
||||
endif()
|
||||
# The following flags are not supported by Clang and can cause warnings
|
||||
@ -20,14 +15,13 @@ else(EIGEN_SYCL_TRISYCL)
|
||||
set(CMAKE_CXX_COMPILER ${ComputeCpp_DEVICE_COMPILER_EXECUTABLE})
|
||||
string(REPLACE "-Wlogical-op" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
|
||||
string(REPLACE "-Wno-psabi" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
|
||||
string(REPLACE "-ansi" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
|
||||
endif()
|
||||
list(APPEND COMPUTECPP_USER_FLAGS
|
||||
-DEIGEN_NO_ASSERTION_CHECKING=1
|
||||
-no-serial-memop
|
||||
-Xclang
|
||||
-cl-mad-enable)
|
||||
endif(EIGEN_SYCL_TRISYCL)
|
||||
endif(EIGEN_SYCL_ComputeCpp)
|
||||
|
||||
FOREACH(example_src ${examples_SRCS})
|
||||
GET_FILENAME_COMPONENT(example ${example_src} NAME_WE)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user