mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-03-31 19:00:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

replace size_t with int everywhere.

Browse Source 
The size_t type means a number of _bytes_, and it was misused as
counting e.g. the number of rows/columns in a matrix. Moreover, it is unsigned,
which can give strange bugs if a signed/unsigned mismatch occurs.
This commit is contained in:
Benoit Jacob 2007-06-01 07:56:24 +00:00
parent 887ff84376
commit 6d749c172a
72 changed files with 764 additions and 764 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tvmet-1.7.1/ChangeLog
View File

@ -3160,7 +3160,7 @@
2003-05-18 19:37 opetzold
* include/tvmet/: Matrix.h, Vector.h: cast to std::size_t for
* include/tvmet/: Matrix.h, Vector.h: cast to int for
iterator concept constructors runtime check.
2003-05-18 18:04 opetzold

6
tvmet-1.7.1/ChangeLog.1
View File

@ -157,11 +157,11 @@
Matrix<> and XprMatrix<> moved here from Matrix.h.
* include/tvmet/MatrixImpl.h: Forgotten macro prefix TVMET_ added.
operator %=,^=,&=,|= have as argument std::size_t since these
operator %=,^=,&=,|= have as argument int since these
are bitops, only int's are allowed/usefull.
* include/tvmet/Matrix.h (class Matrix): operator %=,^=,&=,|= have
as argumeent std::size_t since these are bitops, only int's
as argumeent int since these are bitops, only int's
are allowed/usefull.
* include/tvmet/VectorOperators.h: operators for /=, %= ... <<= for
@ -676,7 +676,7 @@
PromoteTraits<T1, T2>::value_type' is implicitly a typename,
changed, (class MetaMV ): same here.
* include/tvmet/: brute-force query-replace size_t with std::size_t
* include/tvmet/: brute-force query-replace int with int
* doc/intro.doxy: slightly changed and anhanced docs due to positive
test with stlport and gcc-3.1.

2
tvmet-1.7.1/config/config.h.in
View File

@ -123,4 +123,4 @@
#undef restrict
/* Define to `unsigned' if <sys/types.h> does not define. */
#undef size_t
#undef int

8
tvmet-1.7.1/config/ltmain.sh
View File

@ -4641,7 +4641,7 @@ EOF
const char *program_name = NULL;
void * xmalloc (size_t num);
void * xmalloc (int num);
char * xstrdup (const char *string);
char * basename (const char *name);
char * fnqualify(const char *path);
@ -4680,7 +4680,7 @@ EOF
}
void *
xmalloc (size_t num)
xmalloc (int num)
{
void * p = (void *) malloc (num);
if (!p)
@ -4716,7 +4716,7 @@ basename (const char *name)
char *
fnqualify(const char *path)
{
size_t size;
int size;
char *p;
char tmp[LT_PATHMAX + 1];
@ -4743,7 +4743,7 @@ fnqualify(const char *path)
char *
strendzap(char *str, const char *pat)
{
size_t len, patlen;
int len, patlen;
assert(str != NULL);
assert(pat != NULL);

22
tvmet-1.7.1/configure vendored
View File

@ -20545,9 +20545,9 @@ _ACEOF
;;
esac
echo "$as_me:$LINENO: checking for size_t" >&5
echo $ECHO_N "checking for size_t... $ECHO_C" >&6
if test "${ac_cv_type_size_t+set}" = set; then
echo "$as_me:$LINENO: checking for int" >&5
echo $ECHO_N "checking for int... $ECHO_C" >&6
if test "${ac_cv_type_int+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
cat >conftest.$ac_ext <<_ACEOF
@ -20560,9 +20560,9 @@ $ac_includes_default
int
main ()
{
if ((size_t *) 0)
if ((int *) 0)
return 0;
if (sizeof (size_t))
if (sizeof (int))
return 0;
;
return 0;
@ -20590,23 +20590,23 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
ac_status=$?
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; }; then
ac_cv_type_size_t=yes
ac_cv_type_int=yes
else
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_cv_type_size_t=no
ac_cv_type_int=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
echo "${ECHO_T}$ac_cv_type_size_t" >&6
if test $ac_cv_type_size_t = yes; then
echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
echo "${ECHO_T}$ac_cv_type_int" >&6
if test $ac_cv_type_int = yes; then
:
else
cat >>confdefs.h <<_ACEOF
#define size_t unsigned
#define int unsigned
_ACEOF
fi

2
tvmet-1.7.1/doc/usage.dox
View File

@ -152,7 +152,7 @@
2,5,8,
3,6,9 };
std::size_t sz = sizeof(data)/sizeof(T);
int sz = sizeof(data)/sizeof(T);
T* first = data;
T* last = data + sz;

4
tvmet-1.7.1/examples/frob_matrix_norm.cc
View File

@ -27,7 +27,7 @@
using namespace std;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
double
frob_norm(const tvmet::Matrix<T, Rows, Cols>& M) {
return std::sqrt(M(0,0)*M(0,0) + M(1,0)*M(1,0) + M(2,0)*M(2,0)
@ -36,7 +36,7 @@ frob_norm(const tvmet::Matrix<T, Rows, Cols>& M) {
}
namespace tvmet {
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
typename NumericTraits<T>::float_type
norm(const Matrix<T, Rows, Cols>& M) {
return std::sqrt( sum( diag( MtM_prod(M,M) ) ) );

16
tvmet-1.7.1/include/tvmet/BinaryFunctionals.h
View File

@ -42,7 +42,7 @@ struct Fcnl_assign : public BinaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "fcnl_assign<T1="
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">,"
<< std::endl;
@ -71,7 +71,7 @@ struct Fcnl_##NAME : public BinaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) \
<< "Fcnl_" << #NAME << "<T1=" \
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">," \
@ -114,7 +114,7 @@ struct Fcnl_##NAME : public BinaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) \
<< "Fcnl_" << #NAME << "<T1=" \
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">," \
@ -155,7 +155,7 @@ struct Fcnl_##NAME : public BinaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) \
<< "Fcnl_" << #NAME << "<T1=" \
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">," \
@ -189,7 +189,7 @@ struct Fcnl_##NAME : public BinaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) \
<< "Fcnl_" << #NAME << "<T1=" \
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">," \
@ -219,7 +219,7 @@ struct Fcnl_##NAME : public BinaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) \
<< "Fcnl_" << #NAME << "<T1=" \
<< typeid(T1).name() << ", T2=" << typeid(T2).name() << ">," \
@ -260,7 +260,7 @@ struct Fcnl_polar<T,T> : public BinaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "Fcnl_polar<T1="
<< typeid(T).name() << ", T2=" << typeid(T).name() << ">,"
<< std::endl;
@ -286,7 +286,7 @@ struct Fcnl_swap : public BinaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "Fcnl_swap<T1="
<< typeid(T1).name() << ", T2" << typeid(T2).name() << ">,"
<< std::endl;

6
tvmet-1.7.1/include/tvmet/CommaInitializer.h
View File

@ -60,7 +60,7 @@ namespace tvmet {
* will be written random into the memory.
*
*/
template<class Obj, std::size_t LEN>
template<class Obj, int LEN>
class CommaInitializer
{
CommaInitializer();
@ -71,7 +71,7 @@ private:
* \class Initializer
* \brief Helper fo recursive overloaded comma operator.
*/
template<class T, std::size_t N> class Initializer
template<class T, int N> class Initializer
{
Initializer();
Initializer& operator=(const Initializer&);
@ -139,7 +139,7 @@ private:
/*
* Implementation
*/
template<class Obj, std::size_t LEN>
template<class Obj, int LEN>
typename CommaInitializer<Obj, LEN>::template Initializer<typename Obj::value_type, 2>
CommaInitializer<Obj, LEN>::operator,(typename Obj::value_type rhs)
{

48
tvmet-1.7.1/include/tvmet/Matrix.h
View File

@ -40,11 +40,11 @@ namespace tvmet {
/* forwards */
template<class T, std::size_t Rows, std::size_t Cols> class Matrix;
template<class T, int Rows, int Cols> class Matrix;
template<class T,
std::size_t RowsBgn, std::size_t RowsEnd,
std::size_t ColsBgn, std::size_t ColsEnd,
std::size_t RowStride, std::size_t ColStride /*=1*/>
int RowsBgn, int RowsEnd,
int ColsBgn, int ColsEnd,
int RowStride, int ColStride /*=1*/>
class MatrixSliceConstReference; // unused here; for me only
@ -52,7 +52,7 @@ class MatrixSliceConstReference; // unused here; for me only
* \class MatrixConstReference Matrix.h "tvmet/Matrix.h"
* \brief value iterator for ET
*/
template<class T, std::size_t NRows, std::size_t NCols>
template<class T, int NRows, int NCols>
class MatrixConstReference
: public TvmetBase < MatrixConstReference<T, NRows, NCols> >
{
@ -91,13 +91,13 @@ public:
public: // access operators
/** access by index. */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
assert((i < Rows) && (j < Cols));
return m_data[i * Cols + j];
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l)
<< "MatrixConstReference[O=" << ops << "]<"
<< "T=" << typeid(value_type).name() << ">,"
@ -119,7 +119,7 @@ private:
* two paramters are needed). Therefore the cleanest way to do it is
* with operator() rather than with operator[]. \see C++ FAQ Lite 13.8
*/
template<class T, std::size_t NRows, std::size_t NCols>
template<class T, int NRows, int NCols>
class Matrix
{
public:
@ -190,20 +190,20 @@ public: // STL interface
}
/** The size of the matrix. */
static std::size_t size() { return Size; }
static int size() { return Size; }
/** STL vector max_size() - returns allways rows()*cols(). */
static std::size_t max_size() { return Size; }
static int max_size() { return Size; }
/** STL vector empty() - returns allways false. */
static bool empty() { return false; }
public:
/** The number of rows of matrix. */
static std::size_t rows() { return Rows; }
static int rows() { return Rows; }
/** The number of columns of matrix. */
static std::size_t cols() { return Cols; }
static int cols() { return Cols; }
public:
/** Default Destructor */
@ -226,7 +226,7 @@ public:
template<class InputIterator>
explicit Matrix(InputIterator first, InputIterator last)
{
assert(static_cast<std::size_t>(std::distance(first, last)) <= Size);
assert(static_cast<int>(std::distance(first, last)) <= Size);
std::copy(first, last, m_data);
}
@ -235,7 +235,7 @@ public:
* self, there isn't any stored reference to the array pointer.
*/
template<class InputIterator>
explicit Matrix(InputIterator first, std::size_t sz)
explicit Matrix(InputIterator first, int sz)
{
assert(sz <= Size);
std::copy(first, first + sz, m_data);
@ -266,13 +266,13 @@ public: // access operators
const value_type* _tvmet_restrict data() const { return m_data; }
public: // index access operators
value_type& _tvmet_restrict operator()(std::size_t i, std::size_t j) {
value_type& _tvmet_restrict operator()(int i, int j) {
// Note: g++-2.95.3 does have problems on typedef reference
assert((i < Rows) && (j < Cols));
return m_data[i * Cols + j];
}
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
assert((i < Rows) && (j < Cols));
return m_data[i * Cols + j];
}
@ -341,7 +341,7 @@ public: // assign operations
}
private:
template<class Obj, std::size_t LEN> friend class CommaInitializer;
template<class Obj, int LEN> friend class CommaInitializer;
/** This is a helper for assigning a comma separated initializer
list. It's equal to Matrix& operator=(value_type) which does
@ -359,12 +359,12 @@ public: // math operators with scalars
Matrix& operator*=(value_type) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator/=(value_type) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator%=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator^=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator&=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator|=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator<<=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator>>=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator%=(int) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator^=(int) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator&=(int) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator|=(int) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator<<=(int) TVMET_CXX_ALWAYS_INLINE;
Matrix& operator>>=(int) TVMET_CXX_ALWAYS_INLINE;
public: // math operators with matrizes
// NOTE: access using the operators in ns element_wise, since that's what is does
@ -419,7 +419,7 @@ public: // io
static Info info() { return Info(); }
/** Member function for expression level printing. */
std::ostream& print_xpr(std::ostream& os, std::size_t l=0) const;
std::ostream& print_xpr(std::ostream& os, int l=0) const;
/** Member function for printing internal data. */
std::ostream& print_on(std::ostream& os) const;

36
tvmet-1.7.1/include/tvmet/MatrixBinaryFunctions.h
View File

@ -36,7 +36,7 @@ namespace tvmet {
* binary_function(XprMatrix<E, Rows, Cols>, Matrix<T, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -48,7 +48,7 @@ XprMatrix< \
NAME(const Matrix<T1, Rows, Cols>& lhs, \
const Matrix<T2, Cols, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -60,7 +60,7 @@ XprMatrix< \
NAME(const XprMatrix<E, Rows, Cols>& lhs, \
const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T, typename E::value_type>, \
@ -90,7 +90,7 @@ TVMET_DECLARE_MACRO(polar)
* binary_function(Matrix<T, Rows, Cols>, POD)
*/
#define TVMET_DECLARE_MACRO(NAME, TP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T, TP >, \
@ -153,7 +153,7 @@ TVMET_DECLARE_MACRO(pow, long double)
*/
#if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1)
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprBinOp<
Fcnl_pow<T, std::complex<T> >,
@ -166,7 +166,7 @@ pow(const Matrix<T, Rows, Cols>& lhs,
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprBinOp<
Fcnl_pow< std::complex<T>, std::complex<T> >,
@ -183,7 +183,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs,
* \fn pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, const T& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprBinOp<
Fcnl_pow<std::complex<T>, T>,
@ -200,7 +200,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs,
* \fn pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, int rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprBinOp<
Fcnl_pow<std::complex<T>, int>,
@ -213,7 +213,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs,
int rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprBinOp<
Fcnl_polar<T, T>,
@ -243,7 +243,7 @@ polar(const Matrix<T, Rows, Cols>& lhs,
* binary_function(XprMatrix<E, Rows, Cols>, Matrix<T, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -263,7 +263,7 @@ NAME(const Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Cols, Cols>& rhs) { \
expr_type(lhs.const_ref(), rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -283,7 +283,7 @@ NAME(const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& rhs) { \
expr_type(lhs, rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -320,7 +320,7 @@ TVMET_IMPLEMENT_MACRO(polar)
* binary_function(Matrix<T, Rows, Cols>, POD)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, TP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -396,7 +396,7 @@ TVMET_IMPLEMENT_MACRO(pow, long double)
* \fn pow(const Matrix<T, Rows, Cols>& lhs, const std::complex<T>& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprBinOp<
@ -421,7 +421,7 @@ pow(const Matrix<T, Rows, Cols>& lhs, const std::complex<T>& rhs) {
* \fn pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, const std::complex<T>& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprBinOp<
@ -446,7 +446,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, const std::complex<T>& rhs)
* \fn pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, const T& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprBinOp<
@ -471,7 +471,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, const T& rhs) {
* \fn pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, int rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprBinOp<
@ -496,7 +496,7 @@ pow(const Matrix<std::complex<T>, Rows, Cols>& lhs, int rhs) {
* \fn polar(const Matrix<T, Rows, Cols>& lhs, const T& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprBinOp<

24
tvmet-1.7.1/include/tvmet/MatrixEval.h
View File

@ -42,7 +42,7 @@ namespace tvmet {
* \endcode
* \sa \ref compare
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
bool all_elements(const XprMatrix<E, Rows, Cols>& e) {
return meta::Matrix<Rows, Cols, 0, 0>::all_elements(e);
@ -64,7 +64,7 @@ bool all_elements(const XprMatrix<E, Rows, Cols>& e) {
* \endcode
* \sa \ref compare
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
bool any_elements(const XprMatrix<E, Rows, Cols>& e) {
return meta::Matrix<Rows, Cols, 0, 0>::any_elements(e);
@ -87,7 +87,7 @@ bool any_elements(const XprMatrix<E, Rows, Cols>& e) {
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class T2, class T3, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, class T3, int Rows, int Cols>
inline
XprMatrix<
XprEval<
@ -117,7 +117,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1,
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class T2, class E3, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, class E3, int Rows, int Cols>
inline
XprMatrix<
XprEval<
@ -147,7 +147,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1,
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, class T3, std::size_t Rows, std::size_t Cols>
template<class E1, class E2, class T3, int Rows, int Cols>
inline
XprMatrix<
XprEval<
@ -177,7 +177,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1,
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, class E3, std::size_t Rows, std::size_t Cols>
template<class E1, class E2, class E3, int Rows, int Cols>
inline
XprMatrix<
XprEval<
@ -207,7 +207,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1,
* XprMatrix<E1, Rows, Cols> ? XprMatrix<E2, Rows, Cols> : POD
*/
#define TVMET_IMPLEMENT_MACRO(POD) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprEval< \
@ -227,7 +227,7 @@ eval(const XprMatrix<E, Rows, Cols>& e, POD x2, POD x3) { \
expr_type(e, XprLiteral< POD >(x2), XprLiteral< POD >(x3))); \
} \
\
template<class E1, class E3, std::size_t Rows, std::size_t Cols> \
template<class E1, class E3, int Rows, int Cols> \
inline \
XprMatrix< \
XprEval< \
@ -247,7 +247,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1, POD x2, const XprMatrix<E3, Rows, Cols
expr_type(e1, XprLiteral< POD >(x2), e3)); \
} \
\
template<class E1, class E2, std::size_t Rows, std::size_t Cols> \
template<class E1, class E2, int Rows, int Cols> \
inline \
XprMatrix< \
XprEval< \
@ -299,7 +299,7 @@ TVMET_IMPLEMENT_MACRO(long double)
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E, std::size_t Rows, std::size_t Cols, class T>
template<class E, int Rows, int Cols, class T>
inline
XprMatrix<
XprEval<
@ -327,7 +327,7 @@ eval(const XprMatrix<E, Rows, Cols>& e, const std::complex<T>& x2, const std::co
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E3, std::size_t Rows, std::size_t Cols, class T>
template<class E1, class E3, int Rows, int Cols, class T>
inline
XprMatrix<
XprEval<
@ -355,7 +355,7 @@ eval(const XprMatrix<E1, Rows, Cols>& e1, const std::complex<T>& x2, const XprMa
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, std::size_t Rows, std::size_t Cols, class T>
template<class E1, class E2, int Rows, int Cols, class T>
inline
XprMatrix<
XprEval<

208
tvmet-1.7.1/include/tvmet/MatrixFunctions.h
View File

@ -29,8 +29,8 @@
namespace tvmet {
/* forwards */
template<class T, std::size_t Sz> class Vector;
template<class T, std::size_t Sz> class VectorConstReference;
template<class T, int Sz> class Vector;
template<class T, int Sz> class VectorConstReference;
/*********************************************************
@ -49,7 +49,7 @@ template<class T, std::size_t Sz> class VectorConstReference;
* function(Matrix<T, Rows, Cols>, XprMatrix<E, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -61,7 +61,7 @@ XprMatrix< \
NAME (const Matrix<T1, Rows, Cols>& lhs, \
const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -73,7 +73,7 @@ XprMatrix< \
NAME (const XprMatrix<E, Rows, Cols>& lhs, \
const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -101,7 +101,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, POD) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T, POD >, \
@ -113,7 +113,7 @@ XprMatrix< \
NAME (const Matrix<T, Rows, Cols>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< POD, T>, \
@ -165,7 +165,7 @@ TVMET_DECLARE_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -177,7 +177,7 @@ XprMatrix< \
NAME (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -204,8 +204,8 @@ TVMET_DECLARE_MACRO(div)
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
XprMatrix<
XprMMProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -217,8 +217,8 @@ prod(const Matrix<T1, Rows1, Cols1>& lhs,
const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class T2, int Cols2>
XprMatrix<
XprMMProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -230,8 +230,8 @@ prod(const XprMatrix<E1, Rows1, Cols1>& lhs,
const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class E2, int Cols2>
XprMatrix<
XprMMProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -243,8 +243,8 @@ prod(const Matrix<T1, Rows1, Cols1>& lhs,
const XprMatrix<E2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
XprMatrix<
XprMMProductTransposed<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -256,8 +256,8 @@ trans_prod(const Matrix<T1, Rows1, Cols1>& lhs,
const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2> // Rows2 = Rows1
template<class T1, int Rows1, int Cols1,
class T2, int Cols2> // Rows2 = Rows1
XprMatrix<
XprMtMProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -269,8 +269,8 @@ MtM_prod(const Matrix<T1, Rows1, Cols1>& lhs,
const Matrix<T2, Rows1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Rows2>
template<class T1, int Rows1, int Cols1,
class T2, int Rows2>
XprMatrix<
XprMMtProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -287,7 +287,7 @@ MMt_prod(const Matrix<T1, Rows1, Cols1>& lhs,
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T1, class T2, std::size_t Rows, std::size_t Cols>
template<class T1, class T2, int Rows, int Cols>
XprVector<
XprMVProduct<
MatrixConstReference<T1, Rows, Cols>, Rows, Cols, // M(Rows, Cols)
@ -299,7 +299,7 @@ prod(const Matrix<T1, Rows, Cols>& lhs,
const Vector<T2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, class E2, std::size_t Rows, std::size_t Cols>
template<class T1, class E2, int Rows, int Cols>
XprVector<
XprMVProduct<
MatrixConstReference<T1, Rows, Cols>, Rows, Cols,
@ -311,7 +311,7 @@ prod(const Matrix<T1, Rows, Cols>& lhs,
const XprVector<E2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, class T2, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, int Rows, int Cols>
XprVector<
XprMVProduct<
XprMatrix<E1, Rows, Cols>, Rows, Cols, // M(Rows, Cols)
@ -323,7 +323,7 @@ prod(const XprMatrix<E1, Rows, Cols>& lhs,
const Vector<T2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, class T2, std::size_t Rows, std::size_t Cols>
template<class T1, class T2, int Rows, int Cols>
XprVector<
XprMtVProduct<
MatrixConstReference<T1, Rows, Cols>, Rows, Cols, // M(Rows, Cols)
@ -340,7 +340,7 @@ Mtx_prod(const Matrix<T1, Rows, Cols>& lhs,
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprMatrixTranspose<
MatrixConstReference<T, Rows, Cols>
@ -350,12 +350,12 @@ XprMatrix<
trans(const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
typename NumericTraits<T>::sum_type
trace(const Matrix<T, Sz, Sz>& m) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprVector<
XprMatrixRow<
MatrixConstReference<T, Rows, Cols>,
@ -364,10 +364,10 @@ XprVector<
Cols
>
row(const Matrix<T, Rows, Cols>& m,
std::size_t no) TVMET_CXX_ALWAYS_INLINE;
int no) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprVector<
XprMatrixCol<
MatrixConstReference<T, Rows, Cols>,
@ -376,10 +376,10 @@ XprVector<
Rows
>
col(const Matrix<T, Rows, Cols>& m,
std::size_t no) TVMET_CXX_ALWAYS_INLINE;
int no) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprMatrixDiag<
MatrixConstReference<T, Sz, Sz>,
@ -395,41 +395,41 @@ diag(const Matrix<T, Sz, Sz>& m) TVMET_CXX_ALWAYS_INLINE;
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E, std::size_t Rows, std::size_t Cols>
Extremum<typename E::value_type, std::size_t, matrix_tag>
template<class E, int Rows, int Cols>
Extremum<typename E::value_type, int, matrix_tag>
maximum(const XprMatrix<E, Rows, Cols>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
Extremum<T, std::size_t, matrix_tag>
template<class T, int Rows, int Cols>
Extremum<T, int, matrix_tag>
maximum(const Matrix<T, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Rows, std::size_t Cols>
Extremum<typename E::value_type, std::size_t, matrix_tag>
template<class E, int Rows, int Cols>
Extremum<typename E::value_type, int, matrix_tag>
minimum(const XprMatrix<E, Rows, Cols>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
Extremum<T, std::size_t, matrix_tag>
template<class T, int Rows, int Cols>
Extremum<T, int, matrix_tag>
minimum(const Matrix<T, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
typename E::value_type
max(const XprMatrix<E, Rows, Cols>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
T max(const Matrix<T, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
typename E::value_type
min(const XprMatrix<E, Rows, Cols>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
T min(const Matrix<T, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
@ -438,7 +438,7 @@ T min(const Matrix<T, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
XprIdentity<T, Rows, Cols>,
Rows, Cols
@ -456,7 +456,7 @@ XprMatrix<
identity() TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
XprMatrix<
MatrixConstReference<T, Rows, Cols>,
Rows, Cols
@ -480,7 +480,7 @@ cmatrix_ref(const T* mem) TVMET_CXX_ALWAYS_INLINE;
* function(Matrix<T, Rows, Cols>, XprMatrix<E, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -500,7 +500,7 @@ NAME (const Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Rows, Cols>& rhs) { \
expr_type(lhs.const_ref(), rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -520,7 +520,7 @@ NAME (const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& rhs) { \
expr_type(lhs, rhs.const_ref())); \
} \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -556,7 +556,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, POD) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -576,7 +576,7 @@ NAME (const Matrix<T, Rows, Cols>& lhs, POD rhs) { \
expr_type(lhs.const_ref(), XprLiteral< POD >(rhs))); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -636,7 +636,7 @@ TVMET_IMPLEMENT_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -657,7 +657,7 @@ NAME (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -699,8 +699,8 @@ TVMET_IMPLEMENT_MACRO(div)
* \ingroup _binary_function
* \note The rows2 has to be equal to cols1.
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -724,8 +724,8 @@ prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) {
* \brief Evaluate the product of XprMatrix and Matrix.
* \ingroup _binary_function
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class T2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -749,8 +749,8 @@ prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs
* \brief Evaluate the product of Matrix and XprMatrix.
* \ingroup _binary_function
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class E2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -778,8 +778,8 @@ prod(const Matrix<T1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs
* (M_1\,M_2)^T
* \f]
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
inline
XprMatrix<
XprMMProductTransposed<
@ -810,8 +810,8 @@ trans_prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>&
* matrix 1, since matrix 1 is trans - the result is a (Cols1 x Cols2)
* matrix.
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2> // Rows2 = Rows1
template<class T1, int Rows1, int Cols1,
class T2, int Cols2> // Rows2 = Rows1
inline
XprMatrix<
XprMtMProduct<
@ -836,8 +836,8 @@ MtM_prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Rows1, Cols2>& rh
* \ingroup _binary_function
* \note The Cols2 has to be equal to Cols1.
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Rows2>
template<class T1, int Rows1, int Cols1,
class T2, int Rows2>
inline
XprMatrix<
XprMMtProduct<
@ -866,7 +866,7 @@ MMt_prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Rows2, Cols1>& rh
* \brief Function for the matrix-vector-product
* \ingroup _binary_function
*/
template<class T1, class T2, std::size_t Rows, std::size_t Cols>
template<class T1, class T2, int Rows, int Cols>
inline
XprVector<
XprMVProduct<
@ -890,7 +890,7 @@ prod(const Matrix<T1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) {
* \brief Function for the matrix-vector-product
* \ingroup _binary_function
*/
template<class T1, class E2, std::size_t Rows, std::size_t Cols>
template<class T1, class E2, int Rows, int Cols>
inline
XprVector<
XprMVProduct<
@ -914,7 +914,7 @@ prod(const Matrix<T1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) {
* \brief Compute the product of an XprMatrix with a Vector.
* \ingroup _binary_function
*/
template<class E1, class T2, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, int Rows, int Cols>
inline
XprVector<
XprMVProduct<
@ -942,7 +942,7 @@ prod(const XprMatrix<E1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) {
* M^T\, x
* \f]
*/
template<class T1, class T2, std::size_t Rows, std::size_t Cols>
template<class T1, class T2, int Rows, int Cols>
inline
XprVector<
XprMtVProduct<
@ -971,7 +971,7 @@ Mtx_prod(const Matrix<T1, Rows, Cols>& lhs, const Vector<T2, Rows>& rhs) {
* \brief Transpose the matrix
* \ingroup _unary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprMatrixTranspose<
@ -998,7 +998,7 @@ trans(const Matrix<T, Rows, Cols>& rhs) {
* \sum_{k = 0}^{Sz-1} m(k, k)
* \f]
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
typename NumericTraits<T>::sum_type
trace(const Matrix<T, Sz, Sz>& m) {
@ -1007,11 +1007,11 @@ trace(const Matrix<T, Sz, Sz>& m) {
/**
* \fn row(const Matrix<T, Rows, Cols>& m, std::size_t no)
* \fn row(const Matrix<T, Rows, Cols>& m, int no)
* \brief Returns a row vector of the given matrix.
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprVector<
XprMatrixRow<
@ -1020,7 +1020,7 @@ XprVector<
>,
Cols
>
row(const Matrix<T, Rows, Cols>& m, std::size_t no) {
row(const Matrix<T, Rows, Cols>& m, int no) {
typedef XprMatrixRow<
MatrixConstReference<T, Rows, Cols>,
Rows, Cols
@ -1030,11 +1030,11 @@ row(const Matrix<T, Rows, Cols>& m, std::size_t no) {
/**
* \fn col(const Matrix<T, Rows, Cols>& m, std::size_t no)
* \fn col(const Matrix<T, Rows, Cols>& m, int no)
* \brief Returns a column vector of the given matrix.
* \ingroup _binary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprVector<
XprMatrixCol<
@ -1043,7 +1043,7 @@ XprVector<
>,
Rows
>
col(const Matrix<T, Rows, Cols>& m, std::size_t no) {
col(const Matrix<T, Rows, Cols>& m, int no) {
typedef XprMatrixCol<
MatrixConstReference<T, Rows, Cols>,
Rows, Cols
@ -1057,7 +1057,7 @@ col(const Matrix<T, Rows, Cols>& m, std::size_t no) {
* \brief Returns the diagonal vector of the given square matrix.
* \ingroup _unary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprMatrixDiag<
@ -1085,17 +1085,17 @@ diag(const Matrix<T, Sz, Sz>& m) {
* \brief Find the maximum of a matrix expression
* \ingroup _unary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
Extremum<typename E::value_type, std::size_t, matrix_tag>
Extremum<typename E::value_type, int, matrix_tag>
maximum(const XprMatrix<E, Rows, Cols>& e) {
typedef typename E::value_type value_type;
value_type temp(e(0, 0));
std::size_t row_no(0), col_no(0);
int row_no(0), col_no(0);
for(std::size_t i = 0; i != Rows; ++i) {
for(std::size_t j = 0; j != Cols; ++j) {
for(int i = 0; i != Rows; ++i) {
for(int j = 0; j != Cols; ++j) {
if(e(i, j) > temp) {
temp = e(i, j);
row_no = i;
@ -1104,7 +1104,7 @@ maximum(const XprMatrix<E, Rows, Cols>& e) {
}
}
return Extremum<value_type, std::size_t, matrix_tag>(temp, row_no, col_no);
return Extremum<value_type, int, matrix_tag>(temp, row_no, col_no);
}
@ -1113,9 +1113,9 @@ maximum(const XprMatrix<E, Rows, Cols>& e) {
* \brief Find the maximum of a matrix
* \ingroup _unary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
Extremum<T, std::size_t, matrix_tag>
Extremum<T, int, matrix_tag>
maximum(const Matrix<T, Rows, Cols>& m) { return maximum(m.as_expr()); }
@ -1124,17 +1124,17 @@ maximum(const Matrix<T, Rows, Cols>& m) { return maximum(m.as_expr()); }
* \brief Find the minimum of a matrix expression
* \ingroup _unary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
Extremum<typename E::value_type, std::size_t, matrix_tag>
Extremum<typename E::value_type, int, matrix_tag>
minimum(const XprMatrix<E, Rows, Cols>& e) {
typedef typename E::value_type value_type;
value_type temp(e(0, 0));
std::size_t row_no(0), col_no(0);
int row_no(0), col_no(0);
for(std::size_t i = 0; i != Rows; ++i) {
for(std::size_t j = 0; j != Cols; ++j) {
for(int i = 0; i != Rows; ++i) {
for(int j = 0; j != Cols; ++j) {
if(e(i, j) < temp) {
temp = e(i, j);
row_no = i;
@ -1143,7 +1143,7 @@ minimum(const XprMatrix<E, Rows, Cols>& e) {
}
}
return Extremum<value_type, std::size_t, matrix_tag>(temp, row_no, col_no);
return Extremum<value_type, int, matrix_tag>(temp, row_no, col_no);
}
@ -1152,9 +1152,9 @@ minimum(const XprMatrix<E, Rows, Cols>& e) {
* \brief Find the minimum of a matrix
* \ingroup _unary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
Extremum<T, std::size_t, matrix_tag>
Extremum<T, int, matrix_tag>
minimum(const Matrix<T, Rows, Cols>& m) { return minimum(m.as_expr()); }
@ -1163,7 +1163,7 @@ minimum(const Matrix<T, Rows, Cols>& m) { return minimum(m.as_expr()); }
* \brief Find the maximum of a matrix expression
* \ingroup _unary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
typename E::value_type
max(const XprMatrix<E, Rows, Cols>& e) {
@ -1171,8 +1171,8 @@ max(const XprMatrix<E, Rows, Cols>& e) {
value_type temp(e(0, 0));
for(std::size_t i = 0; i != Rows; ++i)
for(std::size_t j = 0; j != Cols; ++j)
for(int i = 0; i != Rows; ++i)
for(int j = 0; j != Cols; ++j)
if(e(i, j) > temp)
temp = e(i, j);
@ -1185,7 +1185,7 @@ max(const XprMatrix<E, Rows, Cols>& e) {
* \brief Find the maximum of a matrix
* \ingroup _unary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
T max(const Matrix<T, Rows, Cols>& m) {
typedef T value_type;
@ -1210,7 +1210,7 @@ T max(const Matrix<T, Rows, Cols>& m) {
* \brief Find the minimum of a matrix expression
* \ingroup _unary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
typename E::value_type
min(const XprMatrix<E, Rows, Cols>& e) {
@ -1218,8 +1218,8 @@ min(const XprMatrix<E, Rows, Cols>& e) {
value_type temp(e(0, 0));
for(std::size_t i = 0; i != Rows; ++i)
for(std::size_t j = 0; j != Cols; ++j)
for(int i = 0; i != Rows; ++i)
for(int j = 0; j != Cols; ++j)
if(e(i, j) < temp)
temp = e(i, j);
@ -1232,7 +1232,7 @@ min(const XprMatrix<E, Rows, Cols>& e) {
* \brief Find the minimum of a matrix
* \ingroup _unary_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
T min(const Matrix<T, Rows, Cols>& m) {
typedef T value_type;
@ -1280,7 +1280,7 @@ T min(const Matrix<T, Rows, Cols>& m) {
*
* \since release 1.6.0
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
XprIdentity<T, Rows, Cols>,
@ -1354,7 +1354,7 @@ identity() {
*
* \since release 1.6.0
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
XprMatrix<
MatrixConstReference<T, Rows, Cols>,

24
tvmet-1.7.1/include/tvmet/MatrixImpl.h
View File

@ -36,8 +36,8 @@ namespace tvmet {
/*
* member operators for i/o
*/
template<class T, std::size_t NRows, std::size_t NCols>
std::ostream& Matrix<T, NRows, NCols>::print_xpr(std::ostream& os, std::size_t l) const
template<class T, int NRows, int NCols>
std::ostream& Matrix<T, NRows, NCols>::print_xpr(std::ostream& os, int l) const
{
os << IndentLevel(l++) << "Matrix[" << ops << "]<"
<< typeid(T).name() << ", " << Rows << ", " << Cols << ">,"
@ -48,7 +48,7 @@ std::ostream& Matrix<T, NRows, NCols>::print_xpr(std::ostream& os, std::size_t l
}
template<class T, std::size_t NRows, std::size_t NCols>
template<class T, int NRows, int NCols>
std::ostream& Matrix<T, NRows, NCols>::print_on(std::ostream& os) const
{
enum {
@ -58,9 +58,9 @@ std::ostream& Matrix<T, NRows, NCols>::print_on(std::ostream& os) const
std::streamsize w = IoPrintHelper<Matrix>::width(dispatch<complex_type>(), *this);
os << std::setw(0) << "[\n";
for(std::size_t i = 0; i < Rows; ++i) {
for(int i = 0; i < Rows; ++i) {
os << " [";
for(std::size_t j = 0; j < (Cols - 1); ++j) {
for(int j = 0; j < (Cols - 1); ++j) {
os << std::setw(w) << this->operator()(i, j) << ", ";
}
os << std::setw(w) << this->operator()(i, Cols - 1)
@ -76,7 +76,7 @@ std::ostream& Matrix<T, NRows, NCols>::print_on(std::ostream& os) const
* member operators with scalars, per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t NRows, std::size_t NCols> \
template<class T, int NRows, int NCols> \
inline \
Matrix<T, NRows, NCols>& \
Matrix<T, NRows, NCols>::operator OP (value_type rhs) { \
@ -93,10 +93,10 @@ TVMET_IMPLEMENT_MACRO(div_eq, /=)
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t NRows, std::size_t NCols> \
template<class T, int NRows, int NCols> \
inline \
Matrix<T, NRows, NCols>& \
Matrix<T, NRows, NCols>::operator OP (std::size_t rhs) { \
Matrix<T, NRows, NCols>::operator OP (int rhs) { \
typedef XprLiteral<value_type> expr_type; \
this->M_##NAME(XprMatrix<expr_type, Rows, Cols>(expr_type(rhs))); \
return *this; \
@ -115,7 +115,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq, >>=)
* member functions (operators) with matrizes, for use with +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, std::size_t NRows, std::size_t NCols> \
template<class T1, int NRows, int NCols> \
template <class T2> \
inline \
Matrix<T1, NRows, NCols>& \
@ -141,7 +141,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq)
* member functions (operators) with expressions, for use width +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t NRows, std::size_t NCols> \
template<class T, int NRows, int NCols> \
template<class E> \
inline \
Matrix<T, NRows, NCols>& \
@ -168,7 +168,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq)
* for use with +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, std::size_t NRows, std::size_t NCols> \
template<class T1, int NRows, int NCols> \
template <class T2> \
inline \
Matrix<T1, NRows, NCols>& \
@ -190,7 +190,7 @@ TVMET_IMPLEMENT_MACRO(div_eq)
* for use width +=,-= ... <<= and aliased(),
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t NRows, std::size_t NCols> \
template<class T, int NRows, int NCols> \
template<class E> \
inline \
Matrix<T, NRows, NCols>& \

108
tvmet-1.7.1/include/tvmet/MatrixOperators.h
View File

@ -32,7 +32,7 @@ namespace tvmet {
*********************************************************/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
std::ostream& operator<<(std::ostream& os,
const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -49,12 +49,12 @@ std::ostream& operator<<(std::ostream& os,
* \todo: the operator*= can have element wise mul oder product, decide!
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
Matrix<T1, Rows, Cols>& \
operator OP (Matrix<T1, Rows, Cols>& lhs, \
const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
Matrix<T, Rows, Cols>& \
operator OP (Matrix<T, Rows, Cols>& lhs, \
const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -92,7 +92,7 @@ namespace element_wise {
* Note: per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -104,7 +104,7 @@ XprMatrix< \
operator OP (const Matrix<T1, Rows, Cols>& lhs, \
const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -116,7 +116,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -143,7 +143,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, POD) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T, POD >, \
@ -155,7 +155,7 @@ XprMatrix< \
operator OP (const Matrix<T, Rows, Cols>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< POD, T>, \
@ -207,7 +207,7 @@ TVMET_DECLARE_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -219,7 +219,7 @@ XprMatrix< \
operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -246,8 +246,8 @@ TVMET_DECLARE_MACRO(div, /)
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
XprMatrix<
XprMMProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1,
@ -259,8 +259,8 @@ operator*(const Matrix<T1, Rows1, Cols1>& lhs,
const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class T2, int Cols2>
XprMatrix<
XprMMProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1,
@ -272,8 +272,8 @@ operator*(const XprMatrix<E1, Rows1, Cols1>& lhs,
const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class E2, int Cols2>
XprMatrix<
XprMMProduct<
MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1,
@ -290,7 +290,7 @@ operator*(const Matrix<T1, Rows1, Cols1>& lhs,
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T1, std::size_t Rows, std::size_t Cols, class T2>
template<class T1, int Rows, int Cols, class T2>
XprVector<
XprMVProduct<
MatrixConstReference<T1, Rows, Cols>, Rows, Cols,
@ -302,7 +302,7 @@ operator*(const Matrix<T1, Rows, Cols>& lhs,
const Vector<T2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T1, class E2, std::size_t Rows, std::size_t Cols>
template<class T1, class E2, int Rows, int Cols>
XprVector<
XprMVProduct<
MatrixConstReference<T1, Rows, Cols>, Rows, Cols,
@ -314,7 +314,7 @@ operator*(const Matrix<T1, Rows, Cols>& lhs,
const XprVector<E2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, class T2, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, int Rows, int Cols>
XprVector<
XprMVProduct<
XprMatrix<E1, Rows, Cols>, Rows, Cols,
@ -338,7 +338,7 @@ operator*(const XprMatrix<E1, Rows, Cols>& lhs,
* Note: operations are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, std::size_t Rows, std::size_t Cols, \
template<class T1, int Rows, int Cols, \
class T2> \
XprMatrix< \
XprBinOp< \
@ -352,7 +352,7 @@ operator OP (const Matrix<T1, Rows, Cols>& lhs, \
const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, \
class T, std::size_t Rows, std::size_t Cols> \
class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -364,7 +364,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols, \
template<class T, int Rows, int Cols, \
class E> \
XprMatrix< \
XprBinOp< \
@ -409,7 +409,7 @@ TVMET_DECLARE_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -421,7 +421,7 @@ XprMatrix< \
operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -454,7 +454,7 @@ TVMET_DECLARE_MACRO(or, ||)
* Note: operations are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, TP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<T, TP >, \
@ -465,7 +465,7 @@ XprMatrix< \
> \
operator OP (const Matrix<T, Rows, Cols>& lhs, TP rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< TP, T>, \
@ -565,7 +565,7 @@ TVMET_DECLARE_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template <class T, std::size_t Rows, std::size_t Cols> \
template <class T, int Rows, int Cols> \
XprMatrix< \
XprUnOp< \
Fcnl_##NAME<T>, \
@ -591,7 +591,7 @@ TVMET_DECLARE_MACRO(neg, -)
* \brief Overload operator for i/o
* \ingroup _binary_operator
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
std::ostream& operator<<(std::ostream& os, const Matrix<T, Rows, Cols>& rhs) {
return rhs.print_on(os);
@ -610,14 +610,14 @@ std::ostream& operator<<(std::ostream& os, const Matrix<T, Rows, Cols>& rhs) {
* \todo: the operator*= can have element wise mul oder product, decide!
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
inline \
Matrix<T1, Rows, Cols>& \
operator OP (Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Rows, Cols>& rhs) { \
return lhs.M_##NAME(rhs); \
} \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
inline \
Matrix<T, Rows, Cols>& \
operator OP (Matrix<T, Rows, Cols>& lhs, const XprMatrix<E, Rows, Cols>& rhs) { \
@ -657,7 +657,7 @@ namespace element_wise {
* Note: per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Rows, std::size_t Cols> \
template<class T1, class T2, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -671,7 +671,7 @@ operator OP (const Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Rows, Cols>& rh
return NAME(lhs, rhs); \
} \
\
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -685,7 +685,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& r
return NAME(lhs, rhs); \
} \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -714,7 +714,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -728,7 +728,7 @@ operator OP (const Matrix<T, Rows, Cols>& lhs, POD rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -782,7 +782,7 @@ TVMET_IMPLEMENT_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -797,7 +797,7 @@ operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
return NAME (lhs, rhs); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -834,8 +834,8 @@ TVMET_IMPLEMENT_MACRO(div, /)
* \note The rows2 has to be equal to cols1.
* \sa prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs)
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class T2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -855,8 +855,8 @@ operator*(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& r
* \ingroup _binary_operator
* \sa prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs)
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class T2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class T2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -876,8 +876,8 @@ operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>
* \ingroup _binary_operator
* \sa prod(const Matrix<T, Rows1, Cols1>& lhs, const XprMatrix<E, Cols1, Cols2>& rhs)
*/
template<class T1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class T1, int Rows1, int Cols1,
class E2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -903,7 +903,7 @@ operator*(const Matrix<T1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>
* \note The length of the Vector has to be equal to the number of Columns.
* \sa prod(const Matrix<T1, Rows, Cols>& m, const Vector<T2, Cols>& v)
*/
template<class T1, std::size_t Rows, std::size_t Cols, class T2>
template<class T1, int Rows, int Cols, class T2>
inline
XprVector<
XprMVProduct<
@ -923,7 +923,7 @@ operator*(const Matrix<T1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) {
* \ingroup _binary_operator
* \sa prod(const Matrix<T, Rows, Cols>& lhs, const XprVector<E, Cols>& rhs)
*/
template<class T1, class E2, std::size_t Rows, std::size_t Cols>
template<class T1, class E2, int Rows, int Cols>
inline
XprVector<
XprMVProduct<
@ -943,7 +943,7 @@ operator*(const Matrix<T1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) {
* \ingroup _binary_operator
* \sa prod(const XprMatrix<E, Rows, Cols>& lhs, const Vector<T, Cols>& rhs)
*/
template<class E1, class T2, std::size_t Rows, std::size_t Cols>
template<class E1, class T2, int Rows, int Cols>
inline
XprVector<
XprMVProduct<
@ -969,7 +969,7 @@ operator*(const XprMatrix<E1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) {
* Note: operations are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, std::size_t Rows, std::size_t Cols, \
template<class T1, int Rows, int Cols, \
class T2> \
inline \
XprMatrix< \
@ -991,7 +991,7 @@ operator OP (const Matrix<T1, Rows, Cols>& lhs, \
} \
\
template<class E, \
class T, std::size_t Rows, std::size_t Cols> \
class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -1010,7 +1010,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& r
return XprMatrix<expr_type, Rows, Cols>(expr_type(lhs, rhs.const_ref())); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols, \
template<class T, int Rows, int Cols, \
class E> \
inline \
XprMatrix< \
@ -1062,7 +1062,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -1083,7 +1083,7 @@ operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \
expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -1125,7 +1125,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* Note: operations are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -1145,7 +1145,7 @@ operator OP (const Matrix<T, Rows, Cols>& lhs, TP rhs) { \
expr_type(lhs.const_ref(), XprLiteral< TP >(rhs))); \
} \
\
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -1254,7 +1254,7 @@ TVMET_IMPLEMENT_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template <class T, std::size_t Rows, std::size_t Cols> \
template <class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \

8
tvmet-1.7.1/include/tvmet/MatrixUnaryFunctions.h
View File

@ -35,7 +35,7 @@ namespace tvmet {
* unary_function(Matrix<T, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \
@ -96,7 +96,7 @@ TVMET_DECLARE_MACRO(finite)
*/
#if defined(TVMET_HAVE_COMPLEX)
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \
@ -127,7 +127,7 @@ TVMET_DECLARE_MACRO(conj)
* unary_function(Matrix<T, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \
@ -194,7 +194,7 @@ TVMET_IMPLEMENT_MACRO(finite)
*/
#if defined(TVMET_HAVE_COMPLEX)
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Rows, std::size_t Cols> \
template<class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \

6
tvmet-1.7.1/include/tvmet/TvmetBase.h
View File

@ -47,15 +47,15 @@ template<class E> class TvmetBase { };
class IndentLevel : public TvmetBase< IndentLevel >
{
public:
IndentLevel(std::size_t level) : m_level(level) { }
IndentLevel(int level) : m_level(level) { }
std::ostream& print_xpr(std::ostream& os) const {
for(std::size_t i = 0; i != m_level; ++i) os << " ";
for(int i = 0; i != m_level; ++i) os << " ";
return os;
}
private:
std::size_t m_level;
int m_level;
};

20
tvmet-1.7.1/include/tvmet/UnaryFunctionals.h
View File

@ -39,7 +39,7 @@ struct Fcnl_not : public UnaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "Fcnl_not<T="
<< typeid(T).name() << ">,"
<< std::endl;
@ -60,7 +60,7 @@ struct Fcnl_##NAME : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(T).name() << ">," \
<< std::endl; \
@ -99,7 +99,7 @@ struct Fcnl_##NAME : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(value_type).name() << ">," \
<< std::endl; \
@ -139,7 +139,7 @@ struct Fcnl_##NAME : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(value_type).name() << ">," \
<< std::endl; \
@ -177,7 +177,7 @@ struct Fcnl_##NAME : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(value_type).name() << ">," \
<< std::endl; \
@ -219,7 +219,7 @@ struct Fcnl_##NAME< POD > : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(value_type).name() << ">," \
<< std::endl; \
@ -260,7 +260,7 @@ struct Fcnl_abs< std::complex<T> > : public UnaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "Fcnl_abs<T="
<< typeid(std::complex<T>).name() << ">,"
<< std::endl;
@ -286,7 +286,7 @@ struct Fcnl_conj< std::complex<T> > : public UnaryFunctional {
}
static
void print_xpr(std::ostream& os, std::size_t l=0) {
void print_xpr(std::ostream& os, int l=0) {
os << IndentLevel(l) << "Fcnl_conj<T="
<< typeid(std::complex<T>).name() << ">,"
<< std::endl;
@ -310,7 +310,7 @@ struct Fcnl_##NAME< std::complex<T> > : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(std::complex<T>).name() << ">," \
<< std::endl; \
@ -341,7 +341,7 @@ struct Fcnl_##NAME : public UnaryFunctional { \
} \
\
static \
void print_xpr(std::ostream& os, std::size_t l=0) { \
void print_xpr(std::ostream& os, int l=0) { \
os << IndentLevel(l) << "Fcnl_" << #NAME << "<T=" \
<< typeid(POD).name() << ">," \
<< std::endl; \

42
tvmet-1.7.1/include/tvmet/Vector.h
View File

@ -37,14 +37,14 @@ namespace tvmet {
/* forwards */
template<class T, std::size_t Sz> class Vector;
template<class T, int Sz> class Vector;
/**
* \class VectorConstReference Vector.h "tvmet/Vector.h"
* \brief Const value iterator for ET
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
class VectorConstReference
: public TvmetBase< VectorConstReference<T, Sz> >
{
@ -82,13 +82,13 @@ public:
public: // access operators
/** access by index. */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
assert(i < Size);
return m_data[i];
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l)
<< "VectorConstReference[O=" << ops << "]<"
<< "T=" << typeid(T).name() << ">,"
@ -104,7 +104,7 @@ private:
* \class Vector Vector.h "tvmet/Vector.h"
* \brief Compile time fixed length vector with evaluation on compile time.
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
class Vector
{
public:
@ -188,10 +188,10 @@ public: // STL interface
static bool empty() { return false; }
/** The size of the vector. */
static std::size_t size() { return Size; }
static int size() { return Size; }
/** STL vector max_size() - returns allways Size. */
static std::size_t max_size() { return Size; }
static int max_size() { return Size; }
public:
/** Default Destructor */
@ -214,7 +214,7 @@ public:
template<class InputIterator>
explicit Vector(InputIterator first, InputIterator last)
{
assert( static_cast<std::size_t>(std::distance(first, last)) <= Size);
assert( static_cast<int>(std::distance(first, last)) <= Size);
std::copy(first, last, m_data);
}
@ -223,7 +223,7 @@ public:
* vector self, there isn't any stored reference to the array pointer.
*/
template<class InputIterator>
explicit Vector(InputIterator first, std::size_t sz)
explicit Vector(InputIterator first, int sz)
{
assert(sz <= Size);
std::copy(first, first + sz, m_data);
@ -330,23 +330,23 @@ public: // access operators
const value_type* _tvmet_restrict data() const { return m_data; }
public: // index access operators
value_type& _tvmet_restrict operator()(std::size_t i) {
value_type& _tvmet_restrict operator()(int i) {
// Note: g++-2.95.3 does have problems on typedef reference
assert(i < Size);
return m_data[i];
}
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
assert(i < Size);
return m_data[i];
}
value_type& _tvmet_restrict operator[](std::size_t i) {
value_type& _tvmet_restrict operator[](int i) {
// Note: g++-2.95.3 does have problems on typedef reference
return this->operator()(i);
}
value_type operator[](std::size_t i) const {
value_type operator[](int i) const {
return this->operator()(i);
}
@ -400,7 +400,7 @@ public: // assign operations
}
private:
template<class Obj, std::size_t LEN> friend class CommaInitializer;
template<class Obj, int LEN> friend class CommaInitializer;
/** This is a helper for assigning a comma separated initializer
list. It's equal to Vector& operator=(value_type) which does
@ -418,12 +418,12 @@ public: // math operators with scalars
Vector& operator*=(value_type) TVMET_CXX_ALWAYS_INLINE;
Vector& operator/=(value_type) TVMET_CXX_ALWAYS_INLINE;
Vector& operator%=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator^=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator&=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator|=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator<<=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator>>=(std::size_t) TVMET_CXX_ALWAYS_INLINE;
Vector& operator%=(int) TVMET_CXX_ALWAYS_INLINE;
Vector& operator^=(int) TVMET_CXX_ALWAYS_INLINE;
Vector& operator&=(int) TVMET_CXX_ALWAYS_INLINE;
Vector& operator|=(int) TVMET_CXX_ALWAYS_INLINE;
Vector& operator<<=(int) TVMET_CXX_ALWAYS_INLINE;
Vector& operator>>=(int) TVMET_CXX_ALWAYS_INLINE;
public: // math assign operators with vectors
// NOTE: access using the operators in ns element_wise, since that's what is does
@ -478,7 +478,7 @@ public: // io
static Info info() { return Info(); }
/** Member function for expression level printing. */
std::ostream& print_xpr(std::ostream& os, std::size_t l=0) const;
std::ostream& print_xpr(std::ostream& os, int l=0) const;
/** Member function for printing internal data. */
std::ostream& print_on(std::ostream& os) const;

36
tvmet-1.7.1/include/tvmet/VectorBinaryFunctions.h
View File

@ -40,7 +40,7 @@ namespace tvmet {
* binary_function(XprVector<E>, Vector<T, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -53,7 +53,7 @@ XprVector< \
NAME(const Vector<T1, Sz>& lhs, \
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -66,7 +66,7 @@ XprVector< \
NAME(const XprVector<E, Sz>& lhs, \
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -97,7 +97,7 @@ TVMET_DECLARE_MACRO(polar)
* binary_function(Vector<T, Sz>, POD)
*/
#define TVMET_DECLARE_MACRO(NAME, TP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -161,7 +161,7 @@ TVMET_DECLARE_MACRO(pow, long double)
*/
#if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1)
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_pow<T, std::complex<T> >,
@ -174,7 +174,7 @@ pow(const Vector<T, Sz>& lhs,
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_pow<std::complex<T>, std::complex<T> >,
@ -187,7 +187,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs,
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_pow<std::complex<T>, T>,
@ -200,7 +200,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs,
const T& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_pow<std::complex<T>, int>,
@ -213,7 +213,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs,
int rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_polar<T, T>,
@ -241,7 +241,7 @@ polar(const Vector<T, Sz>& lhs, const T& rhs) TVMET_CXX_ALWAYS_INLINE;
* binary_function(XprVector<E>, Vector<T, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -261,7 +261,7 @@ NAME(const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \
expr_type(lhs.const_ref(), rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -281,7 +281,7 @@ NAME(const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { \
expr_type(lhs, rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -319,7 +319,7 @@ TVMET_IMPLEMENT_MACRO(polar)
* binary_function(Vector<T, Sz>, POD)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, TP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -395,7 +395,7 @@ TVMET_IMPLEMENT_MACRO(pow, long double)
* \fn pow(const Vector<T, Sz>& lhs, const std::complex<T>& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<
@ -420,7 +420,7 @@ pow(const Vector<T, Sz>& lhs, const std::complex<T>& rhs) {
* \fn pow(const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<
@ -445,7 +445,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs) {
* \fn pow(const Vector<std::complex<T>, Sz>& lhs, const T& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<
@ -470,7 +470,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs, const T& rhs) {
* \fn pow(const Vector<std::complex<T>, Sz>& lhs, int rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<
@ -495,7 +495,7 @@ pow(const Vector<std::complex<T>, Sz>& lhs, int rhs) {
* \fn polar(const Vector<T, Sz>& lhs, const T& rhs)
* \ingroup _binary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<

24
tvmet-1.7.1/include/tvmet/VectorEval.h
View File

@ -47,7 +47,7 @@ namespace tvmet {
* \endcode
* \sa \ref compare
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
bool all_elements(const XprVector<E, Sz>& e) {
return meta::Vector<Sz>::all_elements(e);
@ -69,7 +69,7 @@ bool all_elements(const XprVector<E, Sz>& e) {
* \endcode
* \sa \ref compare
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
bool any_elements(const XprVector<E, Sz>& e) {
return meta::Vector<Sz>::any_elements(e);
@ -91,7 +91,7 @@ bool any_elements(const XprVector<E, Sz>& e) {
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class T2, class T3, std::size_t Sz>
template<class E1, class T2, class T3, int Sz>
inline
XprVector<
XprEval<
@ -119,7 +119,7 @@ eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const Vector<T3, Sz>
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class T2, class E3, std::size_t Sz>
template<class E1, class T2, class E3, int Sz>
inline
XprVector<
XprEval<
@ -147,7 +147,7 @@ eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const XprVector<E3,
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, class T3, std::size_t Sz>
template<class E1, class E2, class T3, int Sz>
inline
XprVector<
XprEval<
@ -175,7 +175,7 @@ eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const Vector<T3,
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, class E3, std::size_t Sz>
template<class E1, class E2, class E3, int Sz>
inline
XprVector<
XprEval<
@ -203,7 +203,7 @@ eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const XprVector<E
* XprVector<E1, Sz> ? XprVector<E2, Sz> : POD
*/
#define TVMET_IMPLEMENT_MACRO(POD) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprEval< \
@ -223,7 +223,7 @@ eval(const XprVector<E, Sz>& e, POD x2, POD x3) { \
expr_type(e, XprLiteral< POD >(x2), XprLiteral< POD >(x3))); \
} \
\
template<class E1, class E3, std::size_t Sz> \
template<class E1, class E3, int Sz> \
inline \
XprVector< \
XprEval< \
@ -243,7 +243,7 @@ eval(const XprVector<E1, Sz>& e1, POD x2, const XprVector<E3, Sz>& e3) { \
expr_type(e1, XprLiteral< POD >(x2), e3)); \
} \
\
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprEval< \
@ -296,7 +296,7 @@ TVMET_IMPLEMENT_MACRO(long double)
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E, std::size_t Sz, class T>
template<class E, int Sz, class T>
inline
XprVector<
XprEval<
@ -323,7 +323,7 @@ eval(const XprVector<E, Sz>& e, std::complex<T> z2, std::complex<T> z3) {
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E3, std::size_t Sz, class T>
template<class E1, class E3, int Sz, class T>
inline
XprVector<
XprEval<
@ -350,7 +350,7 @@ eval(const XprVector<E1, Sz>& e1, std::complex<T> z2, const XprVector<E3, Sz>& e
* This eval is for the a?b:c syntax, since it's not allowed to overload
* these operators.
*/
template<class E1, class E2, std::size_t Sz, class T>
template<class E1, class E2, int Sz, class T>
inline
XprVector<
XprEval<

120
tvmet-1.7.1/include/tvmet/VectorFunctions.h
View File

@ -45,7 +45,7 @@ namespace tvmet {
* function(XprVector<E, Sz>, Vector<T, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -57,7 +57,7 @@ XprVector< \
NAME (const Vector<T1, Sz>& lhs, \
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -69,7 +69,7 @@ XprVector< \
NAME (const XprVector<E, Sz>& lhs, \
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T, typename E::value_type>, \
@ -97,7 +97,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, POD) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< T, POD >, \
@ -109,7 +109,7 @@ XprVector< \
NAME (const Vector<T, Sz>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< POD, T>, \
@ -161,7 +161,7 @@ TVMET_DECLARE_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -173,7 +173,7 @@ XprVector< \
NAME (const Vector<std::complex<T>, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -200,17 +200,17 @@ TVMET_DECLARE_MACRO(div)
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class T, std::size_t Sz>
template<class T, int Sz>
typename NumericTraits<T>::sum_type
sum(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
typename NumericTraits<T>::sum_type
product(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class T1, class T2, std::size_t Sz>
template<class T1, class T2, int Sz>
typename PromoteTraits<T1, T2>::value_type
dot(const Vector<T1, Sz>& lhs,
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -222,17 +222,17 @@ cross(const Vector<T1, 3>& lhs,
const Vector<T2, 3>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
typename NumericTraits<T>::sum_type
norm1(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
typename NumericTraits<T>::sum_type
norm2(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
XprBinOp<
Fcnl_div<T, T>,
@ -248,45 +248,45 @@ normalize(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
* min/max unary functions
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E, std::size_t Sz>
Extremum<typename E::value_type, std::size_t, vector_tag>
template<class E, int Sz>
Extremum<typename E::value_type, int, vector_tag>
maximum(const XprVector<E, Sz>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
Extremum<T, std::size_t, vector_tag>
template<class T, int Sz>
Extremum<T, int, vector_tag>
maximum(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
Extremum<typename E::value_type, std::size_t, vector_tag>
template<class E, int Sz>
Extremum<typename E::value_type, int, vector_tag>
minimum(const XprVector<E, Sz>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
Extremum<T, std::size_t, vector_tag>
template<class T, int Sz>
Extremum<T, int, vector_tag>
minimum(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
typename E::value_type
max(const XprVector<E, Sz>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
T max(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
typename E::value_type
min(const XprVector<E, Sz>& e); // NOT TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
T min(const Vector<T, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class T, std::size_t Sz>
template<class T, int Sz>
XprVector<
VectorConstReference<T, Sz>,
Sz
@ -310,7 +310,7 @@ cvector_ref(const T* mem) TVMET_CXX_ALWAYS_INLINE;
* function(XprVector<E, Sz>, Vector<T, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -330,7 +330,7 @@ NAME (const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \
expr_type(lhs.const_ref(), rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -350,7 +350,7 @@ NAME (const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { \
expr_type(lhs, rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -386,7 +386,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, POD) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -406,7 +406,7 @@ NAME (const Vector<T, Sz>& lhs, POD rhs) { \
expr_type(lhs.const_ref(), XprLiteral< POD >(rhs))); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -466,7 +466,7 @@ TVMET_IMPLEMENT_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -486,7 +486,7 @@ NAME (const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs) { \
expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -531,7 +531,7 @@ TVMET_IMPLEMENT_MACRO(div)
* \sum_{i = 0}^{Sz-1} v[i]
* \f]
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
typename NumericTraits<T>::sum_type
sum(const Vector<T, Sz>& v) {
@ -549,7 +549,7 @@ sum(const Vector<T, Sz>& v) {
* \prod_{i = 0}^{Sz - 1} v[i]
* \f]
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
typename NumericTraits<T>::sum_type
product(const Vector<T, Sz>& v) {
@ -569,7 +569,7 @@ product(const Vector<T, Sz>& v) {
* where lhs is a column vector and rhs is a row vector, both vectors
* have the same dimension.
*/
template<class T1, class T2, std::size_t Sz>
template<class T1, class T2, int Sz>
inline
typename PromoteTraits<T1, T2>::value_type
dot(const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) {
@ -606,7 +606,7 @@ cross(const Vector<T1, 3>& lhs, const Vector<T2, 3>& rhs) {
* |Vector<T, Sz> v| = |v| = \sum_{i=0}^{Sz-1}\,|v[i]|
* \f]
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
typename NumericTraits<T>::sum_type
norm1(const Vector<T, Sz>& v) {
@ -627,7 +627,7 @@ norm1(const Vector<T, Sz>& v) {
*
* \note The internal cast for Vector<int> avoids warnings on sqrt.
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
typename NumericTraits<T>::sum_type
norm2(const Vector<T, Sz>& v) {
@ -646,7 +646,7 @@ norm2(const Vector<T, Sz>& v) {
* \frac{Vector<T, Sz> v}{\sqrt{ \sum_{i=0}^{Sz-1}\,v[i]^2 }}
* \f]
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
XprBinOp<
@ -677,24 +677,24 @@ normalize(const Vector<T, Sz>& v) {
* \brief Find the maximum of a vector expression
* \ingroup _unary_function
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
Extremum<typename E::value_type, std::size_t, vector_tag>
Extremum<typename E::value_type, int, vector_tag>
maximum(const XprVector<E, Sz>& e) {
typedef typename E::value_type value_type;
value_type m_max(e(0));
std::size_t m_idx(0);
int m_idx(0);
// this loop is faster than meta templates!
for(std::size_t i = 1; i != Sz; ++i) {
for(int i = 1; i != Sz; ++i) {
if(e(i) > m_max) {
m_max = e(i);
m_idx = i;
}
}
return Extremum<value_type, std::size_t, vector_tag>(m_max, m_idx);
return Extremum<value_type, int, vector_tag>(m_max, m_idx);
}
@ -703,9 +703,9 @@ maximum(const XprVector<E, Sz>& e) {
* \brief Find the maximum of a vector
* \ingroup _unary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
Extremum<T, std::size_t, vector_tag>
Extremum<T, int, vector_tag>
maximum(const Vector<T, Sz>& v) { return maximum(v.as_expr()); }
@ -714,24 +714,24 @@ maximum(const Vector<T, Sz>& v) { return maximum(v.as_expr()); }
* \brief Find the minimum of a vector expression
* \ingroup _unary_function
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
Extremum<typename E::value_type, std::size_t, vector_tag>
Extremum<typename E::value_type, int, vector_tag>
minimum(const XprVector<E, Sz>& e) {
typedef typename E::value_type value_type;
value_type m_min(e(0));
std::size_t m_idx(0);
int m_idx(0);
// this loop is faster than meta templates!
for(std::size_t i = 1; i != Sz; ++i) {
for(int i = 1; i != Sz; ++i) {
if(e(i) < m_min) {
m_min = e(i);
m_idx = i;
}
}
return Extremum<value_type, std::size_t, vector_tag>(m_min, m_idx);
return Extremum<value_type, int, vector_tag>(m_min, m_idx);
}
@ -740,9 +740,9 @@ minimum(const XprVector<E, Sz>& e) {
* \brief Find the minimum of a vector
* \ingroup _unary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
Extremum<T, std::size_t, vector_tag>
Extremum<T, int, vector_tag>
minimum(const Vector<T, Sz>& v) { return minimum(v.as_expr()); }
@ -751,7 +751,7 @@ minimum(const Vector<T, Sz>& v) { return minimum(v.as_expr()); }
* \brief Find the maximum of a vector expression
* \ingroup _unary_function
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename E::value_type
max(const XprVector<E, Sz>& e) {
@ -760,7 +760,7 @@ max(const XprVector<E, Sz>& e) {
value_type m_max(e(0));
// this loop is faster than meta templates!
for(std::size_t i = 1; i != Sz; ++i)
for(int i = 1; i != Sz; ++i)
if(e(i) > m_max)
m_max = e(i);
@ -773,7 +773,7 @@ max(const XprVector<E, Sz>& e) {
* \brief Find the maximum of a vector
* \ingroup _unary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
T max(const Vector<T, Sz>& v) {
typedef T value_type;
@ -796,7 +796,7 @@ T max(const Vector<T, Sz>& v) {
* \brief Find the minimum of a vector expression
* \ingroup _unary_function
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename E::value_type
min(const XprVector<E, Sz>& e) {
@ -805,7 +805,7 @@ min(const XprVector<E, Sz>& e) {
value_type m_min(e(0));
// this loop is faster than meta templates!
for(std::size_t i = 1; i != Sz; ++i)
for(int i = 1; i != Sz; ++i)
if(e(i) < m_min)
m_min = e(i);
@ -818,7 +818,7 @@ min(const XprVector<E, Sz>& e) {
* \brief Find the minimum of a vector
* \ingroup _unary_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
T min(const Vector<T, Sz>& v) {
typedef T value_type;
@ -860,7 +860,7 @@ T min(const Vector<T, Sz>& v) {
*
* \since release 1.6.0
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
XprVector<
VectorConstReference<T, Sz>,

22
tvmet-1.7.1/include/tvmet/VectorImpl.h
View File

@ -36,8 +36,8 @@ namespace tvmet {
/*
* member operators for i/o
*/
template<class T, std::size_t Sz>
std::ostream& Vector<T, Sz>::print_xpr(std::ostream& os, std::size_t l) const
template<class T, int Sz>
std::ostream& Vector<T, Sz>::print_xpr(std::ostream& os, int l) const
{
os << IndentLevel(l++) << "Vector[" << ops << "]<"
<< typeid(T).name() << ", " << Size << ">,"
@ -48,7 +48,7 @@ std::ostream& Vector<T, Sz>::print_xpr(std::ostream& os, std::size_t l) const
}
template<class T, std::size_t Sz>
template<class T, int Sz>
std::ostream& Vector<T, Sz>::print_on(std::ostream& os) const
{
enum {
@ -58,7 +58,7 @@ std::ostream& Vector<T, Sz>::print_on(std::ostream& os) const
std::streamsize w = IoPrintHelper<Vector>::width(dispatch<complex_type>(), *this);
os << std::setw(0) << "[\n ";
for(std::size_t i = 0; i < (Size - 1); ++i) {
for(int i = 0; i < (Size - 1); ++i) {
os << std::setw(w) << m_data[i] << ", ";
}
os << std::setw(w) << m_data[Size - 1] << "\n]";
@ -71,7 +71,7 @@ std::ostream& Vector<T, Sz>::print_on(std::ostream& os) const
* member operators with scalars, per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
Vector<T, Sz>& Vector<T, Sz>::operator OP (value_type rhs) { \
typedef XprLiteral<value_type> expr_type; \
@ -87,9 +87,9 @@ TVMET_IMPLEMENT_MACRO(div_eq, /=)
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
Vector<T, Sz>& Vector<T, Sz>::operator OP (std::size_t rhs) { \
Vector<T, Sz>& Vector<T, Sz>::operator OP (int rhs) { \
typedef XprLiteral<value_type> expr_type; \
this->M_##NAME(XprVector<expr_type, Size>(expr_type(rhs))); \
return *this; \
@ -108,7 +108,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq, >>=)
* member functions (operators) with vectors, for use with +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, std::size_t Sz> \
template<class T1, int Sz> \
template <class T2> \
inline Vector<T1, Sz>& \
Vector<T1, Sz>::M_##NAME (const Vector<T2, Size>& rhs) { \
@ -133,7 +133,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq)
* member functions (operators) with expressions, for use width +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
template <class E> \
inline \
Vector<T, Sz>& \
@ -160,7 +160,7 @@ TVMET_IMPLEMENT_MACRO(shr_eq)
* for use with +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T1, std::size_t Sz> \
template<class T1, int Sz> \
template <class T2> \
inline \
Vector<T1, Sz>& \
@ -182,7 +182,7 @@ TVMET_IMPLEMENT_MACRO(div_eq)
* for use width +=,-= ... <<=
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
template <class E> \
inline \
Vector<T, Sz>& \

72
tvmet-1.7.1/include/tvmet/VectorOperators.h
View File

@ -32,7 +32,7 @@ namespace tvmet {
*********************************************************/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
std::ostream& operator<<(std::ostream& os,
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -49,12 +49,12 @@ std::ostream& operator<<(std::ostream& os,
* Note: per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
Vector<T1, Sz>& \
operator OP (Vector<T1, Sz>& lhs, \
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, class E, std::size_t Sz> \
template<class T, class E, int Sz> \
Vector<T, Sz>& \
operator OP (Vector<T, Sz>& lhs, \
const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -91,7 +91,7 @@ namespace element_wise {
* operator(XprVector<E, Sz>, Vector<T1, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -103,7 +103,7 @@ XprVector< \
operator OP (const Vector<T1, Sz>& lhs, \
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -115,7 +115,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T, typename E::value_type>, \
@ -143,7 +143,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, POD) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< T, POD >, \
@ -155,7 +155,7 @@ XprVector< \
operator OP (const Vector<T, Sz>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< POD, T>, \
@ -207,7 +207,7 @@ TVMET_DECLARE_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -219,7 +219,7 @@ XprVector< \
operator OP (const Vector<std::complex<T>, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -252,7 +252,7 @@ TVMET_DECLARE_MACRO(div, /) // per se element wise
* Note: operations are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T1, T2>, \
@ -264,7 +264,7 @@ XprVector< \
operator OP (const Vector<T1, Sz>& lhs, \
const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, T>, \
@ -276,7 +276,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<T, typename E::value_type>, \
@ -321,7 +321,7 @@ TVMET_DECLARE_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -333,7 +333,7 @@ XprVector< \
operator OP (const Vector<std::complex<T>, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, std::complex<T> >, \
@ -366,7 +366,7 @@ TVMET_DECLARE_MACRO(or, ||)
* Note: operations are per se element_wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, TP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< T, TP >, \
@ -377,7 +377,7 @@ XprVector< \
> \
operator OP (const Vector<T, Sz>& lhs, TP rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< TP, T>, \
@ -475,7 +475,7 @@ TVMET_DECLARE_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template <class T, std::size_t Sz> \
template <class T, int Sz> \
XprVector< \
XprUnOp< \
Fcnl_##NAME<T>, \
@ -501,7 +501,7 @@ TVMET_DECLARE_MACRO(neg, -)
* \brief Overload operator for i/o
* \ingroup _binary_operator
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
std::ostream& operator<<(std::ostream& os, const Vector<T, Sz>& rhs) {
return rhs.print_on(os);
@ -519,13 +519,13 @@ std::ostream& operator<<(std::ostream& os, const Vector<T, Sz>& rhs) {
* Note: per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline Vector<T1, Sz>& \
operator OP (Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \
return lhs.M_##NAME(rhs); \
} \
\
template<class T, class E, std::size_t Sz> \
template<class T, class E, int Sz> \
inline Vector<T, Sz>& \
operator OP (Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) { \
return lhs.M_##NAME(rhs); \
@ -563,7 +563,7 @@ namespace element_wise {
* operator(XprVector<E, Sz>, Vector<T1, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -577,7 +577,7 @@ operator OP (const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -591,7 +591,7 @@ operator OP (const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -621,7 +621,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -635,7 +635,7 @@ operator OP (const Vector<T, Sz>& lhs, POD rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -689,7 +689,7 @@ TVMET_IMPLEMENT_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -704,7 +704,7 @@ operator OP (const Vector<std::complex<T>, Sz>& lhs, \
return NAME (lhs, rhs); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -741,7 +741,7 @@ TVMET_IMPLEMENT_MACRO(div, /) // per se element wise
* Note: operations are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T1, class T2, std::size_t Sz> \
template<class T1, class T2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -761,7 +761,7 @@ operator OP (const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \
expr_type(lhs.const_ref(), rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -781,7 +781,7 @@ operator OP (const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { \
expr_type(lhs, rhs.const_ref())); \
} \
\
template<class E, class T, std::size_t Sz> \
template<class E, class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -833,7 +833,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -853,7 +853,7 @@ operator OP (const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs)
expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -894,7 +894,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* Note: operations are per se element_wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -914,7 +914,7 @@ operator OP (const Vector<T, Sz>& lhs, TP rhs) { \
expr_type(lhs.const_ref(), XprLiteral< TP >(rhs))); \
} \
\
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -1021,7 +1021,7 @@ TVMET_IMPLEMENT_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template <class T, std::size_t Sz> \
template <class T, int Sz> \
inline \
XprVector< \
XprUnOp< \

8
tvmet-1.7.1/include/tvmet/VectorUnaryFunctions.h
View File

@ -35,7 +35,7 @@ namespace tvmet {
* unary_function(Vector<T, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprUnOp< \
Fcnl_##NAME<T>, \
@ -95,7 +95,7 @@ TVMET_DECLARE_MACRO(finite)
*/
#if defined(TVMET_HAVE_COMPLEX)
#define TVMET_DECLARE_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
XprVector< \
XprUnOp< \
Fcnl_##NAME< std::complex<T> >, \
@ -125,7 +125,7 @@ TVMET_DECLARE_MACRO(conj)
* unary_function(Vector<T, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprUnOp< \
@ -192,7 +192,7 @@ TVMET_IMPLEMENT_MACRO(finite)
*/
#if defined(TVMET_HAVE_COMPLEX)
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class T, std::size_t Sz> \
template<class T, int Sz> \
inline \
XprVector< \
XprUnOp< \

2
tvmet-1.7.1/include/tvmet/config/config-vc71.h
View File

@ -220,7 +220,7 @@
#endif
/* Define to `unsigned' if <sys/types.h> does not define. */
/* #undef _tvmet_size_t */
/* #undef _tvmet_int */

2
tvmet-1.7.1/include/tvmet/config/config-vc71.h.in
View File

@ -220,7 +220,7 @@
#endif
/* Define to `unsigned' if <sys/types.h> does not define. */
/* #undef _tvmet_size_t */
/* #undef _tvmet_int */

16
tvmet-1.7.1/include/tvmet/loop/Gemm.h
View File

@ -38,14 +38,14 @@ namespace loop {
* \f]
* \par Example:
* \code
* template<class T, std::size_t Rows1, std::size_t Cols1, std::size_t Cols2>
* template<class T, int Rows1, int Cols1, int Cols2>
* inline
* void
* prod(const Matrix<T, Rows1, Cols1>& lhs, const Matrix<T, Cols1, Cols2>& rhs,
* Matrix<T, Rows1, Cols2>& dest)
* {
* for (std::size_t i = 0; i != Rows1; ++i) {
* for (std::size_t j = 0; j != Cols2; ++j) {
* for (int i = 0; i != Rows1; ++i) {
* for (int j = 0; j != Cols2; ++j) {
* dest(i, j) = tvmet::loop::gemm<Rows1, Cols1, Cols2>().prod(lhs, rhs, i, j);
* }
* }
@ -54,8 +54,8 @@ namespace loop {
* \note The number of rows of rhs matrix have to be equal to cols of lhs matrix.
* The result is a (Rows1 x Cols2) matrix.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2>
template<int Rows1, int Cols1,
int Cols2>
class gemm
{
gemm(const gemm&);
@ -77,13 +77,13 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
>::value_type sum(0);
std::size_t k(0);
std::size_t n(N);
int k(0);
int n(N);
// Duff's device
switch(count % 8) {

16
tvmet-1.7.1/include/tvmet/loop/Gemmt.h
View File

@ -38,14 +38,14 @@ namespace loop {
* \f]
* \par Example:
* \code
* template<class T, std::size_t Rows1, std::size_t Cols1, std::size_t Cols2>
* template<class T, int Rows1, int Cols1, int Cols2>
* inline
* void
* prod(const Matrix<T, Rows1, Cols1>& lhs, const Matrix<T, Rows2, Cols1>& rhs,
* Matrix<T, Rows1, Rows2>& dest)
* {
* for (std::size_t i = 0; i != Rows1; ++i) {
* for (std::size_t j = 0; j != Rows2; ++j) {
* for (int i = 0; i != Rows1; ++i) {
* for (int j = 0; j != Rows2; ++j) {
* dest(i, j) = tvmet::loop::gemmt<Rows1, Cols1, Cols1>().prod(lhs, rhs, i, j);
* }
* }
@ -54,8 +54,8 @@ namespace loop {
* \note The number of cols of rhs matrix have to be equal to cols of rhs matrix.
* The result is a (Rows1 x Rows2) matrix.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2 /* unused */>
template<int Rows1, int Cols1,
int Cols2 /* unused */>
class gemmt
{
gemmt(const gemmt&);
@ -77,13 +77,13 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
>::value_type sum(0);
std::size_t k(0);
std::size_t n(N);
int k(0);
int n(N);
// Duff's device
switch(count % 8) {

16
tvmet-1.7.1/include/tvmet/loop/Gemtm.h
View File

@ -38,14 +38,14 @@ namespace loop {
* \f]
* \par Example:
* \code
* template<class T, std::size_t Rows1, std::size_t Cols1, std::size_t Cols2>
* template<class T, int Rows1, int Cols1, int Cols2>
* inline
* void
* prod(const Matrix<T, Rows1, Cols1>& lhs, const Matrix<T, Rows1, Cols2>& rhs,
* Matrix<T, Cols2, Cols1>& dest)
* {
* for (std::size_t i = 0; i != Cols1; ++i) {
* for (std::size_t j = 0; j != Cols2; ++j) {
* for (int i = 0; i != Cols1; ++i) {
* for (int j = 0; j != Cols2; ++j) {
* dest(i, j) = tvmet::loop::gemtm<Rows1, Cols1, Cols2>::prod(lhs, rhs, i, j);
* }
* }
@ -55,8 +55,8 @@ namespace loop {
* since lhs matrix 1 is transposed.
* The result is a (Cols1 x Cols2) matrix.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2>
template<int Rows1, int Cols1,
int Cols2>
class gemtm
{
gemtm(const gemtm&);
@ -78,13 +78,13 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
>::value_type sum(0);
std::size_t k(0);
std::size_t n(N);
int k(0);
int n(N);
// Duff's device
switch(count % 8) {

12
tvmet-1.7.1/include/tvmet/loop/Gemtv.h
View File

@ -38,19 +38,19 @@ namespace loop {
* \f]
* \par Example:
* \code
* template<class T, std::size_t Rows, std::size_t Cols>
* template<class T, int Rows, int Cols>
* inline
* void
* prod(const Matrix<T, Rows, Cols>& lhs, const Vector<T, Rows>& rhs,
* Vector<T, Cols>& dest)
* {
* for (std::size_t i = 0; i != Cols; ++i) {
* for (int i = 0; i != Cols; ++i) {
* dest(i) = tvmet::loop::gemtv<Rows, Cols>().prod(lhs, rhs, i);
* }
* }
* \endcode
*/
template<std::size_t Rows, std::size_t Cols>
template<int Rows, int Cols>
class gemtv
{
gemtv(const gemtv&);
@ -72,13 +72,13 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i) {
prod(const E1& lhs, const E2& rhs, int i) {
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
>::value_type sum(0);
std::size_t j(0);
std::size_t n(N);
int j(0);
int n(N);
// Duff's device
switch(count % 8) {

12
tvmet-1.7.1/include/tvmet/loop/Gemv.h
View File

@ -38,19 +38,19 @@ namespace loop {
* \f]
* \par Example:
* \code
* template<class T, std::size_t Rows, std::size_t Cols>
* template<class T, int Rows, int Cols>
* inline
* void
* prod(const Matrix<T, Rows, Cols>& lhs, const Vector<T, Cols>& rhs,
* Vector<T, Rows>& dest)
* {
* for (std::size_t i = 0; i != Rows; ++i) {
* for (int i = 0; i != Rows; ++i) {
* dest(i) = tvmet::loop::gemv<Rows, Cols>().prod(lhs, rhs, i);
* }
* }
* \endcode
*/
template<std::size_t Rows, std::size_t Cols>
template<int Rows, int Cols>
class gemv
{
gemv(const gemv&);
@ -72,13 +72,13 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i) {
prod(const E1& lhs, const E2& rhs, int i) {
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
>::value_type sum(0);
std::size_t j(0);
std::size_t n(N);
int j(0);
int n(N);
// Duff's device
switch(count % 8) {

6
tvmet-1.7.1/include/tvmet/loop/Matrix.h
View File

@ -33,7 +33,7 @@ namespace loop {
* \class Matrix Matrix.h "tvmet/loop/Matrix.h"
* \brief Loop %Matrix class using expression and loop templates.
*/
template<std::size_t Rows, std::size_t Cols>
template<int Rows, int Cols>
class Matrix
{
Matrix(const Matrix&);
@ -47,8 +47,8 @@ public:
template<class E1, class E2, class Assign>
static inline
void assign(E1& lhs, const E2& rhs, const Assign& assign_fn) {
for(std::size_t i = 0; i != Rows; ++i)
for(std::size_t j = 0; j != Cols; ++j)
for(int i = 0; i != Rows; ++i)
for(int j = 0; j != Cols; ++j)
assign_fn.apply_on(lhs(i, j), rhs(i, j));
}
};

4
tvmet-1.7.1/include/tvmet/loop/Vector.h
View File

@ -33,7 +33,7 @@ namespace loop {
* \class Vector Vector.h "tvmet/loop/Vector.h"
* \brief Loop %Vector class using expression and loop templates.
*/
template<std::size_t Sz>
template<int Sz>
class Vector
{
Vector(const Vector&);
@ -47,7 +47,7 @@ public:
template<class E1, class E2, class Assign>
static inline
void assign(E1& lhs, const E2& rhs, const Assign& assign_fn) {
for(std::size_t i = 0; i != Sz; ++i)
for(int i = 0; i != Sz; ++i)
assign_fn.apply_on(lhs(i), rhs(i));
}
};

10
tvmet-1.7.1/include/tvmet/meta/Gemm.h
View File

@ -40,9 +40,9 @@ namespace meta {
* \f]
* \note The rows of matrix 2 have to be equal to cols of matrix 1.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2,
std::size_t K>
template<int Rows1, int Cols1,
int Cols2,
int K>
class gemm
{
gemm();
@ -61,7 +61,7 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
return lhs(i, K) * rhs(K, j)
+ gemm<Rows1 * doIt, Cols1 * doIt,
Cols2 * doIt,
@ -84,7 +84,7 @@ class gemm<0,0,0,0>
public:
template<class E1, class E2>
static inline
XprNull prod(const E1&, const E2&, std::size_t, std::size_t) {
XprNull prod(const E1&, const E2&, int, int) {
return XprNull();
}
};

10
tvmet-1.7.1/include/tvmet/meta/Gemmt.h
View File

@ -41,9 +41,9 @@ namespace meta {
* \note The rows of matrix 2 have to be equal to cols of matrix 1. The result
* is a rows1 * cols2 matrix.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2,
std::size_t K>
template<int Rows1, int Cols1,
int Cols2,
int K>
class gemmt
{
gemmt();
@ -62,7 +62,7 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
return lhs(i, K) * rhs(j, K)
+ gemmt<Rows1 * doIt, Cols1 * doIt,
Cols2 * doIt,
@ -85,7 +85,7 @@ class gemmt<0,0,0,0>
public:
template<class E1, class E2>
static inline
XprNull prod(const E1&, const E2&, std::size_t, std::size_t) {
XprNull prod(const E1&, const E2&, int, int) {
return XprNull();
}
};

10
tvmet-1.7.1/include/tvmet/meta/Gemtm.h
View File

@ -43,9 +43,9 @@ namespace meta {
* matrix.
*/
template<std::size_t Rows1, std::size_t Cols1,
std::size_t Cols2,
std::size_t K>
template<int Rows1, int Cols1,
int Cols2,
int K>
class gemtm
{
private:
@ -65,7 +65,7 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int i, int j) {
return lhs(K, i) * rhs(K, j)
+ gemtm<Rows1 * doIt, Cols1 * doIt,
Cols2 * doIt,
@ -88,7 +88,7 @@ class gemtm<0,0,0,0>
public:
template<class E1, class E2>
static inline
XprNull prod(const E1&, const E2&, std::size_t, std::size_t) {
XprNull prod(const E1&, const E2&, int, int) {
return XprNull();
}
};

8
tvmet-1.7.1/include/tvmet/meta/Gemtv.h
View File

@ -39,8 +39,8 @@ namespace meta {
* M^T\,v
* \f]
*/
template<std::size_t Rows, std::size_t Cols,
std::size_t I>
template<int Rows, int Cols,
int I>
class gemtv
{
gemtv();
@ -60,7 +60,7 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t j) {
prod(const E1& lhs, const E2& rhs, int j) {
return lhs(I, j) * rhs(I)
+ gemtv<Rows * doIt, Cols * doIt,
(I+1)* doIt>::prod(lhs, rhs, j);
@ -82,7 +82,7 @@ class gemtv<0,0,0>
public:
template<class E1, class E2>
static inline
XprNull prod(const E1&, const E2&, std::size_t) {
XprNull prod(const E1&, const E2&, int) {
return XprNull();
}
};

8
tvmet-1.7.1/include/tvmet/meta/Gemv.h
View File

@ -39,8 +39,8 @@ namespace meta {
* M\,v
* \f]
*/
template<std::size_t Rows, std::size_t Cols,
std::size_t J>
template<int Rows, int Cols,
int J>
class gemv
{
gemv();
@ -60,7 +60,7 @@ public:
typename E1::value_type,
typename E2::value_type
>::value_type
prod(const E1& lhs, const E2& rhs, std::size_t i) {
prod(const E1& lhs, const E2& rhs, int i) {
return lhs(i, J) * rhs(J)
+ gemv<Rows * doIt, Cols * doIt,
(J+1)* doIt>::prod(lhs, rhs, i);
@ -82,7 +82,7 @@ class gemv<0,0,0>
public:
template<class E1, class E2>
static inline
XprNull prod(const E1&, const E2&, std::size_t) {
XprNull prod(const E1&, const E2&, int) {
return XprNull();
}
};

4
tvmet-1.7.1/include/tvmet/meta/Matrix.h
View File

@ -36,8 +36,8 @@ namespace meta {
* \class Matrix Matrix.h "tvmet/meta/Matrix.h"
* \brief Meta %Matrix class using expression and meta templates.
*/
template<std::size_t Rows, std::size_t Cols,
std::size_t M=0, std::size_t N=0>
template<int Rows, int Cols,
int M=0, int N=0>
class Matrix
{
Matrix();

4
tvmet-1.7.1/include/tvmet/meta/Vector.h
View File

@ -30,7 +30,7 @@
namespace tvmet {
/* forwards */
template<class T, std::size_t Sz> class Vector;
template<class T, int Sz> class Vector;
namespace meta {
@ -40,7 +40,7 @@ namespace meta {
* \class Vector Vector.h "tvmet/meta/Vector.h"
* \brief Meta %Vector class using expression templates
*/
template<std::size_t Sz, std::size_t K=0>
template<int Sz, int K=0>
class Vector
{
Vector();

26
tvmet-1.7.1/include/tvmet/util/General.h
View File

@ -27,8 +27,8 @@
/** forward */
namespace tvmet {
template<class T, std::size_t Rows, std::size_t Cols> class Matrix;
template<class T, std::size_t Sz> class Vector;
template<class T, int Rows, int Cols> class Matrix;
template<class T, int Sz> class Vector;
}
namespace tvmet {
@ -45,16 +45,16 @@ namespace util {
* \brief General matrix matrix multiplication using loops.
* \ingroup _util_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
void
Gemm(const Matrix<T, Rows, Cols>& m1, const Matrix<T, Rows, Cols>& m2,
Matrix<T, Rows, Cols>& m3)
{
for (std::size_t i = 0; i < Rows; ++i) {
for (std::size_t j = 0; j < Cols; ++j) {
for (int i = 0; i < Rows; ++i) {
for (int j = 0; j < Cols; ++j) {
T sum(0);
for (std::size_t k = 0; k < Cols; ++k) {
for (int k = 0; k < Cols; ++k) {
sum += m1(i,k) * m2(k,j);
}
m3(i,j) = sum;
@ -68,15 +68,15 @@ Gemm(const Matrix<T, Rows, Cols>& m1, const Matrix<T, Rows, Cols>& m2,
* \brief General matrix vector multiplication using loops.
* \ingroup _util_function
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
inline
void
Gemv(const Matrix<T, Rows, Cols>& m, const Vector<T, Cols>& v,
Vector<T, Cols>& v2)
{
for (std::size_t i = 0; i < Rows; ++i){
for (int i = 0; i < Rows; ++i){
v2(i) = T(0); // clean up before use
for (std::size_t j = 0; j < Cols; ++j) {
for (int j = 0; j < Cols; ++j) {
v2(i) += m(i,j) * v(j);
}
}
@ -88,13 +88,13 @@ Gemv(const Matrix<T, Rows, Cols>& m, const Vector<T, Cols>& v,
* \brief General vector vector elementwise multiplication using loop.
* \ingroup _util_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
void
Gevvmul(const Vector<T, Sz>& v1, const Vector<T, Sz>& v2,
Vector<T, Sz>& v3)
{
for(std::size_t i = 0; i < Sz; ++i)
for(int i = 0; i < Sz; ++i)
v3(i) = v1(i) * v2(i);
}
@ -104,13 +104,13 @@ Gevvmul(const Vector<T, Sz>& v1, const Vector<T, Sz>& v2,
* \brief General vector vector elementwise multiplication using loop.
* \ingroup _util_function
*/
template<class T, std::size_t Sz>
template<class T, int Sz>
inline
void
Gevvadd(const Vector<T, Sz>& v1, const Vector<T, Sz>& v2,
Vector<T, Sz>& v3)
{
for(std::size_t i = 0; i < Sz; ++i)
for(int i = 0; i < Sz; ++i)
v3(i) = v1(i) + v2(i);
}

6
tvmet-1.7.1/include/tvmet/xpr/BinOperator.h
View File

@ -68,17 +68,17 @@ public:
#endif
/** Index operator, evaluates the expression inside. */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
return BinOp::apply_on(m_lhs(i), m_rhs(i));
}
/** Index operator for arrays/matrices */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
return BinOp::apply_on(m_lhs(i, j), m_rhs(i, j));
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprBinOp[O="<< ops << ", (O1=" << ops_lhs << ", O2=" << ops_rhs << ")]<"
<< std::endl;

6
tvmet-1.7.1/include/tvmet/xpr/Eval.h
View File

@ -77,17 +77,17 @@ public:
public: //access
/** index operator for vectors. */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
return m_expr1(i) ? m_expr2(i) : m_expr3(i);
}
/** index operator for matrizes. */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
return m_expr1(i, j) ? m_expr2(i, j) : m_expr3(i, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprEval[" << ops << ", ("
<< ops_expr1 << ", " << ops_expr2 << ", " << ops_expr3 << ")]<"

6
tvmet-1.7.1/include/tvmet/xpr/Identity.h
View File

@ -20,7 +20,7 @@ namespace tvmet {
* \since release 1.6.0
* \sa identity
*/
template<class T, std::size_t Rows, std::size_t Cols>
template<class T, int Rows, int Cols>
struct XprIdentity
: public TvmetBase< XprIdentity<T, Rows, Cols> >
{
@ -38,12 +38,12 @@ public:
public:
/** access by index. */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
return i==j ? 1 : 0;
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprIdentity[O="<< ops << ")]<"
<< std::endl;

6
tvmet-1.7.1/include/tvmet/xpr/Literal.h
View File

@ -63,13 +63,13 @@ public:
#endif
/** Index operator, gives the value for vectors. */
value_type operator()(std::size_t) const { return m_data; }
value_type operator()(int) const { return m_data; }
/** Index operator for arrays/matrices. */
value_type operator()(std::size_t, std::size_t) const { return m_data; }
value_type operator()(int, int) const { return m_data; }
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++) << "XprLiteral[O=" << ops << "]<T="
<< typeid(value_type).name()
<< ">," << std::endl;

12
tvmet-1.7.1/include/tvmet/xpr/MMProduct.h
View File

@ -39,8 +39,8 @@ namespace tvmet {
* \f]
* \note The Rows2 has to be equal to Cols1.
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
class XprMMProduct
: public TvmetBase< XprMMProduct<E1, Rows1, Cols1, E2, Cols2> >
{
@ -83,7 +83,7 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemm(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemm(dispatch<true>, const E1& lhs, const E2& rhs, int i, int j) {
return meta::gemm<Rows1, Cols1,
Cols2,
0>::prod(lhs, rhs, i, j);
@ -91,19 +91,19 @@ private:
/** Wrapper for loop gemm. */
static inline
value_type do_gemm(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemm(dispatch<false>, const E1& lhs, const E2& rhs, int i, int j) {
return loop::gemm<Rows1, Cols1, Cols2>::prod(lhs, rhs, i, j);
}
public:
/** index operator for arrays/matrices */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
TVMET_RT_CONDITION((i < Rows1) && (j < Cols2), "XprMMProduct Bounce Violation")
return do_gemm(dispatch<use_meta>(), m_lhs, m_rhs, i, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMMProduct["
<< (use_meta ? "M" : "L") << ", O=" << ops

12
tvmet-1.7.1/include/tvmet/xpr/MMProductTransposed.h
View File

@ -40,8 +40,8 @@ namespace tvmet {
* \note The Rows2 has to be equal to Cols1.
* The result is a (Cols2 x Rows1) matrix.
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
class XprMMProductTransposed
: public TvmetBase< XprMMProductTransposed<E1, Rows1, Cols1, E2, Cols2> >
{
@ -83,7 +83,7 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemm(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemm(dispatch<true>, const E1& lhs, const E2& rhs, int i, int j) {
return meta::gemm<Rows1, Cols1,
Cols2,
0>::prod(lhs, rhs, i, j);
@ -91,19 +91,19 @@ private:
/** Wrapper for loop gemm. */
static inline
value_type do_gemm(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemm(dispatch<false>, const E1& lhs, const E2& rhs, int i, int j) {
return loop::gemm<Rows1, Cols1, Cols2>::prod(lhs, rhs, i, j);
}
public:
/** index operator for arrays/matrices */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
TVMET_RT_CONDITION((i < Cols2) && (j < Rows1), "XprMMProductTransposed Bounce Violation")
return do_gemm(dispatch<use_meta>(), m_lhs, m_rhs, j, i);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMMProductTransposed["
<< (use_meta ? "M" : "L") << ", O=" << ops

12
tvmet-1.7.1/include/tvmet/xpr/MMtProduct.h
View File

@ -40,8 +40,8 @@ namespace tvmet {
* \note The number of cols of rhs matrix have to be equal to cols of rhs matrix.
* The result is a (Rows1 x Rows2) matrix.
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
class XprMMtProduct
: public TvmetBase< XprMMtProduct<E1, Rows1, Cols1, E2, Cols2> >
{
@ -85,7 +85,7 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemmt(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemmt(dispatch<true>, const E1& lhs, const E2& rhs, int i, int j) {
return meta::gemmt<Rows1, Cols1,
Cols2,
0>::prod(lhs, rhs, i, j);
@ -93,19 +93,19 @@ private:
/** Wrapper for loop gemm. */
static inline
value_type do_gemmt(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemmt(dispatch<false>, const E1& lhs, const E2& rhs, int i, int j) {
return loop::gemmt<Rows1, Cols1, Cols1>::prod(lhs, rhs, i, j);
}
public:
/** index operator for arrays/matrices */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
TVMET_RT_CONDITION((i < Rows1) && (j < Rows2), "XprMMtProduct Bounce Violation")
return do_gemmt(dispatch<use_meta>(), m_lhs, m_rhs, i, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMMtProduct["
<< (use_meta ? "M" : "L") << ", O=" << ops

10
tvmet-1.7.1/include/tvmet/xpr/MVProduct.h
View File

@ -38,7 +38,7 @@ namespace tvmet {
* M\,v
* \f]
*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
class XprMVProduct
: public TvmetBase< XprMVProduct<E1, Rows, Cols, E2> >
@ -81,27 +81,27 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemv(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t j) {
value_type do_gemv(dispatch<true>, const E1& lhs, const E2& rhs, int j) {
return meta::gemv<Rows, Cols,
0>::prod(lhs, rhs, j);
}
/** Wrapper for loop gemm. */
static inline
value_type do_gemv(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t j) {
value_type do_gemv(dispatch<false>, const E1& lhs, const E2& rhs, int j) {
return loop::gemv<Rows, Cols>::prod(lhs, rhs, j);
}
public:
/** index operator, returns the expression by index. This is the vector
style since a matrix*vector gives a vector. */
value_type operator()(std::size_t j) const {
value_type operator()(int j) const {
TVMET_RT_CONDITION(j < Rows , "XprMVProduct Bounce Violation")
return do_gemv(dispatch<use_meta>(), m_lhs, m_rhs, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMVProduct["
<< (use_meta ? "M" : "L") << ", O=" << ops

8
tvmet-1.7.1/include/tvmet/xpr/Matrix.h
View File

@ -31,7 +31,7 @@ namespace tvmet {
/* forwards */
template <class T, std::size_t Rows, std::size_t Cols> class Matrix;
template <class T, int Rows, int Cols> class Matrix;
/**
* \class XprMatrix Matrix.h "tvmet/xpr/Matrix.h"
@ -46,7 +46,7 @@ template <class T, std::size_t Rows, std::size_t Cols> class Matrix;
* actually implements the expression.
* \note leave the CCtors non-explicit to allow implicit type conversation.
*/
template<class E, std::size_t NRows, std::size_t NCols>
template<class E, int NRows, int NCols>
class XprMatrix
: public TvmetBase< XprMatrix<E, NRows, NCols> >
{
@ -86,7 +86,7 @@ public:
#endif
/** access by index. */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
TVMET_RT_CONDITION((i < Rows) && (j < Cols), "XprMatrix Bounce Violation")
return m_expr(i, j);
}
@ -116,7 +116,7 @@ public:
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMatrix["
<< (use_meta ? "M" : "L") << ", O=" << ops << "]<"

12
tvmet-1.7.1/include/tvmet/xpr/MatrixBinaryFunctions.h
View File

@ -35,7 +35,7 @@ namespace tvmet {
* binary_function(XprMatrix<E1, Rows, Cols>, XprMatrix<E2, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E1, std::size_t Rows, std::size_t Cols, class E2> \
template<class E1, int Rows, int Cols, class E2> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
@ -65,7 +65,7 @@ TVMET_DECLARE_MACRO(pow)
* binary_function(XprMatrix<E, Rows, Cols>, POD)
*/
#define TVMET_DECLARE_MACRO(NAME, TP) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, TP >, \
@ -129,7 +129,7 @@ TVMET_DECLARE_MACRO(pow, long double)
* binary_function(XprMatrix<E, Rows, Cols>, std::complex<>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
@ -164,7 +164,7 @@ TVMET_DECLARE_MACRO(yn)
* binary_function(XprMatrix<E1, Rows, Cols>, XprMatrix<E2, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E1, std::size_t Rows, std::size_t Cols, class E2> \
template<class E1, int Rows, int Cols, class E2> \
inline \
XprMatrix< \
XprBinOp< \
@ -202,7 +202,7 @@ TVMET_IMPLEMENT_MACRO(pow)
* binary_function(XprMatrix<E, Rows, Cols>, POD)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, TP) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -274,7 +274,7 @@ TVMET_IMPLEMENT_MACRO(pow, long double)
* binary_function(XprMatrix<E, Rows, Cols>, std::complex<>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
inline \
XprMatrix< \
XprBinOp< \

10
tvmet-1.7.1/include/tvmet/xpr/MatrixCol.h
View File

@ -31,7 +31,7 @@ namespace tvmet {
* \class XprMatrixCol MatrixCol.h "tvmet/xpr/MatrixCol.h"
* \brief Expression on matrix used for access on the column vector.
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
class XprMatrixCol
: public TvmetBase< XprMatrixCol<E, Rows, Cols> >
{
@ -50,7 +50,7 @@ public:
public:
/** Constructor. */
explicit XprMatrixCol(const E& e, std::size_t no)
explicit XprMatrixCol(const E& e, int no)
: m_expr(e), m_col(no)
{
TVMET_RT_CONDITION(no < Cols, "XprMatrixCol Bounce Violation")
@ -63,13 +63,13 @@ public:
{ }
#endif
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
TVMET_RT_CONDITION(i < Rows, "XprMatrixCol Bounce Violation")
return m_expr(i, m_col);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMatrixCol[O=" << ops << ", (O=" << ops_expr << ")]<"
<< std::endl;
@ -82,7 +82,7 @@ public: // debugging Xpr parse tree
private:
const E m_expr;
const std::size_t m_col;
const int m_col;
};

6
tvmet-1.7.1/include/tvmet/xpr/MatrixDiag.h
View File

@ -31,7 +31,7 @@ namespace tvmet {
* \class XprMatrixDiag MatrixDiag.h "tvmet/xpr/MatrixDiag.h"
* \brief Expression on matrix used for access on the diagonal vector.
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
class XprMatrixDiag
: public TvmetBase< XprMatrixDiag<E, Sz> >
{
@ -62,13 +62,13 @@ public:
#endif
/** index operator for arrays/matrizes */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
TVMET_RT_CONDITION(i < Sz, "XprMatrixDiag Bounce Violation")
return m_expr(i, i);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMatrixDiag[O=" << ops << ", (O=" << ops_expr << ")]<"
<< std::endl;

100
tvmet-1.7.1/include/tvmet/xpr/MatrixFunctions.h
View File

@ -28,13 +28,13 @@ namespace tvmet {
/* forwards */
template<class T, std::size_t Rows, std::size_t Cols> class Matrix;
template<class T, std::size_t Sz> class Vector;
template<class E, std::size_t Sz> class XprVector;
template<class T, int Rows, int Cols> class Matrix;
template<class T, int Sz> class Vector;
template<class E, int Sz> class XprVector;
template<class E> class XprMatrixTranspose;
template<class E, std::size_t Sz> class XprMatrixDiag;
template<class E, std::size_t Rows, std::size_t Cols> class XprMatrixRow;
template<class E, std::size_t Rows, std::size_t Cols> class XprMatrixCol;
template<class E, int Sz> class XprMatrixDiag;
template<class E, int Rows, int Cols> class XprMatrixRow;
template<class E, int Rows, int Cols> class XprMatrixCol;
/*********************************************************
@ -51,7 +51,7 @@ template<class E, std::size_t Rows, std::size_t Cols> class XprMatrixCol;
* function(XprMatrix<E1, Rows, Cols>, XprMatrix<E2, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E1, class E2, std::size_t Rows, std::size_t Cols> \
template<class E1, class E2, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
@ -79,7 +79,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, POD) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, POD >, \
@ -91,7 +91,7 @@ XprMatrix< \
NAME (const XprMatrix<E, Rows, Cols>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< POD, typename E::value_type>, \
@ -143,7 +143,7 @@ TVMET_DECLARE_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
@ -155,7 +155,7 @@ XprMatrix< \
NAME (const XprMatrix<E, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, typename E::value_type>, \
@ -182,8 +182,8 @@ TVMET_DECLARE_MACRO(div)
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
XprMatrix<
XprMMProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -195,8 +195,8 @@ prod(const XprMatrix<E1, Rows1, Cols1>& lhs,
const XprMatrix<E2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
XprMatrix<
XprMMProductTransposed<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -208,8 +208,8 @@ trans_prod(const XprMatrix<E1, Rows1, Cols1>& lhs,
const XprMatrix<E2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2> // Rows2 = Rows1
template<class E1, int Rows1, int Cols1,
class E2, int Cols2> // Rows2 = Rows1
XprMatrix<
XprMtMProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -221,8 +221,8 @@ MtM_prod(const XprMatrix<E1, Rows1, Cols1>& lhs,
const XprMatrix<E2, Rows1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Rows2> // Cols2 = Cols1
template<class E1, int Rows1, int Cols1,
class E2, int Rows2> // Cols2 = Cols1
XprMatrix<
XprMMtProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -239,7 +239,7 @@ MMt_prod(const XprMatrix<E1, Rows1, Cols1>& lhs,
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
XprVector<
XprMVProduct<
@ -257,7 +257,7 @@ prod(const XprMatrix<E1, Rows, Cols>& lhs,
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
XprMatrix<
XprMatrixTranspose<
XprMatrix<E, Rows, Cols>
@ -268,13 +268,13 @@ trans(const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
#if 0 // XXX needs declaration of meta::Matrix<Sz, Sz, 0, 0>::trace
template<class E, std::size_t Sz>
template<class E, int Sz>
typename NumericTraits<typename E::value_type>::sum_type
trace(const XprMatrix<E, Sz, Sz>& m)TVMET_CXX_ALWAYS_INLINE;
#endif
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
XprVector<
XprMatrixRow<
XprMatrix<E, Rows, Cols>,
@ -283,10 +283,10 @@ XprVector<
Cols
>
row(const XprMatrix<E, Rows, Cols>& m,
std::size_t no) TVMET_CXX_ALWAYS_INLINE;
int no) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
XprVector<
XprMatrixCol<
XprMatrix<E, Rows, Cols>,
@ -294,10 +294,10 @@ XprVector<
>,
Rows
>
col(const XprMatrix<E, Rows, Cols>& m, std::size_t no) TVMET_CXX_ALWAYS_INLINE;
col(const XprMatrix<E, Rows, Cols>& m, int no) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
XprVector<
XprMatrixDiag<
XprMatrix<E, Sz, Sz>,
@ -322,7 +322,7 @@ diag(const XprMatrix<E, Sz, Sz>& m) TVMET_CXX_ALWAYS_INLINE;
* function(XprMatrix<E1, Rows, Cols>, XprMatrix<E2, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E1, class E2, std::size_t Rows, std::size_t Cols> \
template<class E1, class E2, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -358,7 +358,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, POD) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -378,7 +378,7 @@ NAME (const XprMatrix<E, Rows, Cols>& lhs, POD rhs) { \
expr_type(lhs, XprLiteral< POD >(rhs))); \
} \
\
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -438,7 +438,7 @@ TVMET_IMPLEMENT_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, class T, std::size_t Rows, std::size_t Cols> \
template<class E, class T, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -459,7 +459,7 @@ NAME (const XprMatrix<E, Rows, Cols>& lhs, \
expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class T, class E, std::size_t Rows, std::size_t Cols> \
template<class T, class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -505,8 +505,8 @@ TVMET_IMPLEMENT_MACRO(div)
* \note The numer of Rows2 has to be equal to Cols1.
* \ingroup _binary_function
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -534,8 +534,8 @@ prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>&
* \note The numer of Rows2 has to be equal to Cols1.
* \ingroup _binary_function
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
inline
XprMatrix<
XprMMProductTransposed<
@ -565,8 +565,8 @@ trans_prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Co
* matrix.
* \ingroup _binary_function
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2> // Rows2 = Rows1
template<class E1, int Rows1, int Cols1,
class E2, int Cols2> // Rows2 = Rows1
inline
XprMatrix<
XprMtMProduct<
@ -590,8 +590,8 @@ MtM_prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Rows1, Cols
* \ingroup _binary_function
* \note The cols2 has to be equal to cols1.
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Rows2> // Cols2 = Cols1
template<class E1, int Rows1, int Cols1,
class E2, int Rows2> // Cols2 = Cols1
inline
XprMatrix<
XprMMtProduct<
@ -619,7 +619,7 @@ MMt_prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Rows2, Cols
* \brief Evaluate the product of XprMatrix and XprVector.
* \ingroup _binary_function
*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
inline
XprVector<
@ -648,7 +648,7 @@ prod(const XprMatrix<E1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) {
* \brief Transpose an expression matrix.
* \ingroup _unary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
XprMatrix<
XprMatrixTranspose<
@ -675,7 +675,7 @@ trans(const XprMatrix<E, Rows, Cols>& rhs) {
* \sum_{k = 0}^{Sz-1} m(k, k)
* \f]
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename NumericTraits<typename E::value_type>::sum_type
trace(const XprMatrix<E, Sz, Sz>& m) {
@ -685,11 +685,11 @@ trace(const XprMatrix<E, Sz, Sz>& m) {
/**
* \fn row(const XprMatrix<E, Rows, Cols>& m, std::size_t no)
* \fn row(const XprMatrix<E, Rows, Cols>& m, int no)
* \brief Returns a row vector of the given matrix.
* \ingroup _binary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
XprVector<
XprMatrixRow<
@ -698,7 +698,7 @@ XprVector<
>,
Cols
>
row(const XprMatrix<E, Rows, Cols>& m, std::size_t no) {
row(const XprMatrix<E, Rows, Cols>& m, int no) {
typedef XprMatrixRow<
XprMatrix<E, Rows, Cols>,
Rows, Cols
@ -709,11 +709,11 @@ row(const XprMatrix<E, Rows, Cols>& m, std::size_t no) {
/**
* \fn col(const XprMatrix<E, Rows, Cols>& m, std::size_t no)
* \fn col(const XprMatrix<E, Rows, Cols>& m, int no)
* \brief Returns a column vector of the given matrix.
* \ingroup _binary_function
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
inline
XprVector<
XprMatrixCol<
@ -722,7 +722,7 @@ XprVector<
>,
Rows
>
col(const XprMatrix<E, Rows, Cols>& m, std::size_t no) {
col(const XprMatrix<E, Rows, Cols>& m, int no) {
typedef XprMatrixCol<
XprMatrix<E, Rows, Cols>,
Rows, Cols
@ -737,7 +737,7 @@ col(const XprMatrix<E, Rows, Cols>& m, std::size_t no) {
* \brief Returns the diagonal vector of the given square matrix.
* \ingroup _unary_function
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
XprVector<
XprMatrixDiag<

56
tvmet-1.7.1/include/tvmet/xpr/MatrixOperators.h
View File

@ -46,7 +46,7 @@ namespace tvmet {
* size [varg].
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E1, std::size_t Rows1, std::size_t Cols1, \
template<class E1, int Rows1, int Cols1, \
class E2> \
XprMatrix< \
XprBinOp< \
@ -74,7 +74,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, POD) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, POD >, \
@ -86,7 +86,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E,std::size_t Rows, std::size_t Cols> \
template<class E,int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<POD, typename E::value_type>, \
@ -138,7 +138,7 @@ TVMET_DECLARE_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
@ -150,7 +150,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
@ -183,8 +183,8 @@ TVMET_DECLARE_MACRO(div, /)
* \ingroup _binary_operator
* \sa prod(XprMatrix<E1, Rows1, Cols1> lhs, XprMatrix<E2, Cols1, Cols2> rhs)
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
XprMatrix<
XprMMProduct<
XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
@ -207,7 +207,7 @@ operator*(const XprMatrix<E1, Rows1, Cols1>& lhs,
* \ingroup _binary_operator
* \sa prod(XprMatrix<E1, Rows, Cols> lhs, XprVector<E2, Cols> rhs)
*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
XprVector<
XprMVProduct<
@ -230,7 +230,7 @@ operator*(const XprMatrix<E1, Rows, Cols>& lhs,
* Note: operations are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E1, std::size_t Rows, std::size_t Cols, \
template<class E1, int Rows, int Cols, \
class E2> \
XprMatrix< \
XprBinOp< \
@ -275,7 +275,7 @@ TVMET_DECLARE_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
@ -287,7 +287,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
@ -320,7 +320,7 @@ TVMET_DECLARE_MACRO(or, ||)
* Note: operations are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, TP) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<typename E::value_type, TP >, \
@ -332,7 +332,7 @@ XprMatrix< \
operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
TP rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
XprMatrix< \
XprBinOp< \
Fcnl_##NAME<TP, typename E::value_type>, \
@ -431,7 +431,7 @@ TVMET_DECLARE_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template <class E, std::size_t Rows, std::size_t Cols> \
template <class E, int Rows, int Cols> \
XprMatrix< \
XprUnOp< \
Fcnl_##NAME<typename E::value_type>, \
@ -468,7 +468,7 @@ TVMET_DECLARE_MACRO(neg, -)
* size [varg].
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E1, std::size_t Rows1, std::size_t Cols1, \
template<class E1, int Rows1, int Cols1, \
class E2> \
inline \
XprMatrix< \
@ -499,7 +499,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -513,7 +513,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, POD rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class E,std::size_t Rows, std::size_t Cols> \
template<class E,int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -567,7 +567,7 @@ TVMET_IMPLEMENT_MACRO(div, /, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
inline \
XprMatrix< \
XprBinOp< \
@ -582,7 +582,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
return NAME (lhs, rhs); \
} \
\
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
inline \
XprMatrix< \
XprBinOp< \
@ -618,8 +618,8 @@ TVMET_IMPLEMENT_MACRO(div, /)
* \ingroup _binary_operator
* \sa prod(XprMatrix<E1, Rows1, Cols1> lhs, XprMatrix<E2, Cols1, Cols2> rhs)
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
inline
XprMatrix<
XprMMProduct<
@ -644,7 +644,7 @@ operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Col
* \ingroup _binary_operator
* \sa prod(XprMatrix<E1, Rows, Cols> lhs, XprVector<E2, Cols> rhs)
*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
inline
XprVector<
@ -669,7 +669,7 @@ operator*(const XprMatrix<E1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs)
* Note: operations are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E1, std::size_t Rows, std::size_t Cols, \
template<class E1, int Rows, int Cols, \
class E2> \
inline \
XprMatrix< \
@ -722,7 +722,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
inline \
XprMatrix< \
XprBinOp< \
@ -743,7 +743,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class E, std::size_t Rows, std::size_t Cols, class T> \
template<class E, int Rows, int Cols, class T> \
inline \
XprMatrix< \
XprBinOp< \
@ -785,7 +785,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* Note: operations are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -805,7 +805,7 @@ operator OP (const XprMatrix<E, Rows, Cols>& lhs, TP rhs) { \
expr_type(lhs, XprLiteral< TP >(rhs))); \
} \
\
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprBinOp< \
@ -913,7 +913,7 @@ TVMET_IMPLEMENT_MACRO(or, ||, long double)
* Note: per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template <class E, std::size_t Rows, std::size_t Cols> \
template <class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \

10
tvmet-1.7.1/include/tvmet/xpr/MatrixRow.h
View File

@ -31,7 +31,7 @@ namespace tvmet {
* \class XprMatrixRow MatrixRow.h "tvmet/xpr/MatrixRow.h"
* \brief Expression on matrix used for access on the row vector.
*/
template<class E, std::size_t Rows, std::size_t Cols>
template<class E, int Rows, int Cols>
class XprMatrixRow
: public TvmetBase< XprMatrixRow<E, Rows, Cols> >
{
@ -50,7 +50,7 @@ public:
public:
/** Constructor. */
explicit XprMatrixRow(const E& e, std::size_t no)
explicit XprMatrixRow(const E& e, int no)
: m_expr(e), m_row(no)
{
TVMET_RT_CONDITION(no < Rows, "XprMatrixRow Bounce Violation")
@ -63,13 +63,13 @@ public:
{ }
#endif
value_type operator()(std::size_t j) const {
value_type operator()(int j) const {
TVMET_RT_CONDITION(j < Cols, "XprMatrixRow Bounce Violation")
return m_expr(m_row, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMatrixRow[O=" << ops << ", (O=" << ops_expr << ")]<"
<< std::endl;
@ -82,7 +82,7 @@ public: // debugging Xpr parse tree
private:
const E m_expr;
const std::size_t m_row;
const int m_row;
};

4
tvmet-1.7.1/include/tvmet/xpr/MatrixTranspose.h
View File

@ -62,10 +62,10 @@ public:
/** index operator for arrays/matrices. This simple swap the index
access for transpose. */
value_type operator()(std::size_t i, std::size_t j) const { return m_expr(j, i); }
value_type operator()(int i, int j) const { return m_expr(j, i); }
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMatrixTranspose[O=" << ops << ", (O=" << ops_expr << ")]<"
<< std::endl;

4
tvmet-1.7.1/include/tvmet/xpr/MatrixUnaryFunctions.h
View File

@ -36,7 +36,7 @@ namespace tvmet {
* unary_function(XprMatrix<E, Rows, Cols>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \
@ -101,7 +101,7 @@ TVMET_DECLARE_MACRO(finite)
* unary_function(XprMatrix<E, Rows, Cols>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, std::size_t Rows, std::size_t Cols> \
template<class E, int Rows, int Cols> \
inline \
XprMatrix< \
XprUnOp< \

12
tvmet-1.7.1/include/tvmet/xpr/MtMProduct.h
View File

@ -41,8 +41,8 @@ namespace tvmet {
* since lhs matrix 1 is transposed.
* The result is a (Cols1 x Cols2) matrix.
*/
template<class E1, std::size_t Rows1, std::size_t Cols1,
class E2, std::size_t Cols2>
template<class E1, int Rows1, int Cols1,
class E2, int Cols2>
class XprMtMProduct
: public TvmetBase< XprMtMProduct<E1, Rows1, Cols1, E2, Cols2> >
{
@ -84,7 +84,7 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemtm(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemtm(dispatch<true>, const E1& lhs, const E2& rhs, int i, int j) {
return meta::gemtm<Rows1, Cols1,
Cols2,
0>::prod(lhs, rhs, i, j);
@ -92,20 +92,20 @@ private:
/** Wrapper for loop gemm. */
static inline
value_type do_gemtm(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t i, std::size_t j) {
value_type do_gemtm(dispatch<false>, const E1& lhs, const E2& rhs, int i, int j) {
return loop::gemtm<Rows1, Cols1,
Cols2>::prod(lhs, rhs, i, j);
}
public:
/** index operator for arrays/matrices */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
TVMET_RT_CONDITION((i < Cols1) && (j < Cols2), "XprMtMProduct Bounce Violation")
return do_gemtm(dispatch<use_meta>(), m_lhs, m_rhs, i, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMtMProduct["
<< (use_meta ? "M" : "L") << ", O=" << ops

10
tvmet-1.7.1/include/tvmet/xpr/MtVProduct.h
View File

@ -38,7 +38,7 @@ namespace tvmet {
* M^T\,v
* \f]
*/
template<class E1, std::size_t Rows, std::size_t Cols,
template<class E1, int Rows, int Cols,
class E2>
class XprMtVProduct
: public TvmetBase< XprMtVProduct<E1, Rows, Cols, E2> >
@ -81,26 +81,26 @@ public:
private:
/** Wrapper for meta gemm. */
static inline
value_type do_gemtv(dispatch<true>, const E1& lhs, const E2& rhs, std::size_t i) {
value_type do_gemtv(dispatch<true>, const E1& lhs, const E2& rhs, int i) {
return meta::gemtv<Rows, Cols, 0>::prod(lhs, rhs, i);
}
/** Wrapper for loop gemm. */
static inline
value_type do_gemtv(dispatch<false>, const E1& lhs, const E2& rhs, std::size_t i) {
value_type do_gemtv(dispatch<false>, const E1& lhs, const E2& rhs, int i) {
return loop::gemtv<Rows, Cols>::prod(lhs, rhs, i);
}
public:
/** index operator, returns the expression by index. This is the vector
style since a matrix*vector gives a vector. */
value_type operator()(std::size_t j) const {
value_type operator()(int j) const {
TVMET_RT_CONDITION(j < Cols , "XprMtVProduct Bounce Violation")
return do_gemtv(dispatch<use_meta>(), m_lhs, m_rhs, j);
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprMtVProduct[O=" << ops << ", (O1=" << ops_lhs << ", O2=" << ops_rhs << ")]<"
<< std::endl;

2
tvmet-1.7.1/include/tvmet/xpr/Null.h
View File

@ -40,7 +40,7 @@ public:
explicit XprNull() { }
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l) << "XprNull[O=0]" << std::endl;
}
};

6
tvmet-1.7.1/include/tvmet/xpr/UnOperator.h
View File

@ -64,17 +64,17 @@ public:
#endif
/** Index operator, evaluates the expression inside. */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
return UnOp::apply_on(m_expr(i));
}
/** index operator for arrays/matrices. */
value_type operator()(std::size_t i, std::size_t j) const {
value_type operator()(int i, int j) const {
return UnOp::apply_on(m_expr(i, j));
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprUnOp[O="<< ops << ", (O=" << ops_expr << ")]<"
<< std::endl;

10
tvmet-1.7.1/include/tvmet/xpr/Vector.h
View File

@ -31,7 +31,7 @@ namespace tvmet {
/* forwards */
template <class T, std::size_t Sz> class Vector;
template <class T, int Sz> class Vector;
/**
* \class XprVector Vector.h "tvmet/xpr/Vector.h"
@ -46,7 +46,7 @@ template <class T, std::size_t Sz> class Vector;
* actually implements the expression.
* \note leave the Ctors non-explicit to allow implicit type conversation.
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
class XprVector : public TvmetBase< XprVector<E, Sz> >
{
XprVector();
@ -83,13 +83,13 @@ public:
#endif
/** const index operator for vectors. */
value_type operator()(std::size_t i) const {
value_type operator()(int i) const {
TVMET_RT_CONDITION(i < Size, "XprVector Bounce Violation")
return m_expr(i);
}
/** const index operator for vectors. */
value_type operator[](std::size_t i) const {
value_type operator[](int i) const {
return this->operator()(i);
}
@ -118,7 +118,7 @@ public:
}
public: // debugging Xpr parse tree
void print_xpr(std::ostream& os, std::size_t l=0) const {
void print_xpr(std::ostream& os, int l=0) const {
os << IndentLevel(l++)
<< "XprVector["
<< (use_meta ? "M" : "L") << ", O=" << ops << "]<"

12
tvmet-1.7.1/include/tvmet/xpr/VectorBinaryFunctions.h
View File

@ -36,7 +36,7 @@ namespace tvmet {
* binary_function(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -67,7 +67,7 @@ TVMET_DECLARE_MACRO(polar)
* binary_function(XprVector<E, Sz>, POD)
*/
#define TVMET_DECLARE_MACRO(NAME, TP) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -132,7 +132,7 @@ TVMET_DECLARE_MACRO(pow, long double)
* binary_function(XprVector<E, Sz>, std::complex<>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -167,7 +167,7 @@ TVMET_DECLARE_MACRO(pow)
* binary_function(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -205,7 +205,7 @@ TVMET_IMPLEMENT_MACRO(polar)
* binary_function(XprVector<E, Sz>, POD)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, TP) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -277,7 +277,7 @@ TVMET_IMPLEMENT_MACRO(pow, long double)
* binary_function(XprVector<E, Sz>, std::complex<>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \

54
tvmet-1.7.1/include/tvmet/xpr/VectorFunctions.h
View File

@ -28,7 +28,7 @@ namespace tvmet {
/* forwards */
template<class T, std::size_t Sz> class Vector;
template<class T, int Sz> class Vector;
/*********************************************************
@ -45,7 +45,7 @@ template<class T, std::size_t Sz> class Vector;
* function(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
@ -73,7 +73,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, POD) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< typename E::value_type, POD >, \
@ -85,7 +85,7 @@ XprVector< \
NAME (const XprVector<E, Sz>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< POD, typename E::value_type>, \
@ -137,7 +137,7 @@ TVMET_DECLARE_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< typename E::value_type, std::complex<T> >, \
@ -149,7 +149,7 @@ XprVector< \
NAME (const XprVector<E, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
XprVector< \
XprBinOp< \
Fcnl_##NAME< std::complex<T>, typename E::value_type>, \
@ -176,17 +176,17 @@ TVMET_DECLARE_MACRO(div)
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
template<class E, std::size_t Sz>
template<class E, int Sz>
typename NumericTraits<typename E::value_type>::sum_type
sum(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
typename NumericTraits<typename E::value_type>::sum_type
product(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E1, class E2, std::size_t Sz>
template<class E1, class E2, int Sz>
typename PromoteTraits<
typename E1::value_type,
typename E2::value_type
@ -195,13 +195,13 @@ dot(const XprVector<E1, Sz>& lhs,
const XprVector<E2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class T, class E, std::size_t Sz>
template<class T, class E, int Sz>
typename PromoteTraits<T, typename E::value_type>::value_type
dot(const Vector<T, Sz>& lhs,
const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E, class T, std::size_t Sz>
template<class E, class T, int Sz>
typename PromoteTraits<T, typename E::value_type>::value_type
dot(const XprVector<E, Sz>& lhs,
const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE;
@ -233,17 +233,17 @@ cross(const XprVector<E, 3>& lhs,
const Vector<T, 3>& rhs) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
typename NumericTraits<typename E::value_type>::sum_type
norm1(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
typename NumericTraits<typename E::value_type>::sum_type
norm2(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
template<class E, std::size_t Sz>
template<class E, int Sz>
XprVector<
XprBinOp<
Fcnl_div<typename E::value_type, typename E::value_type>,
@ -264,7 +264,7 @@ normalize(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE;
* function(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -299,7 +299,7 @@ namespace element_wise {
* Note: - operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, POD) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -319,7 +319,7 @@ NAME (const XprVector<E, Sz>& lhs, POD rhs) { \
expr_type(lhs, XprLiteral< POD >(rhs))); \
} \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -379,7 +379,7 @@ TVMET_IMPLEMENT_MACRO(div, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -399,7 +399,7 @@ NAME (const XprVector<E, Sz>& lhs, const std::complex<T>& rhs) { \
expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -444,7 +444,7 @@ TVMET_IMPLEMENT_MACRO(div)
* \sum_{i = 0}^{Sz-1} v[i]
* \f]
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename NumericTraits<typename E::value_type>::sum_type
sum(const XprVector<E, Sz>& v) {
@ -462,7 +462,7 @@ sum(const XprVector<E, Sz>& v) {
* \prod_{i = 0}^{Sz - 1} v[i]
* \f]
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename NumericTraits<typename E::value_type>::sum_type
product(const XprVector<E, Sz>& v) {
@ -482,7 +482,7 @@ product(const XprVector<E, Sz>& v) {
* where lhs is a column vector and rhs is a row vector, both vectors
* have the same dimension.
*/
template<class E1, class E2, std::size_t Sz>
template<class E1, class E2, int Sz>
inline
typename PromoteTraits<
typename E1::value_type,
@ -505,7 +505,7 @@ dot(const XprVector<E1, Sz>& lhs, const XprVector<E2, Sz>& rhs) {
* where lhs is a column vector and rhs is a row vector, both vectors
* have the same dimension.
*/
template<class T, class E, std::size_t Sz>
template<class T, class E, int Sz>
inline
typename PromoteTraits<T, typename E::value_type>::value_type
dot(const Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) {
@ -525,7 +525,7 @@ dot(const Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) {
* where lhs is a column vector and rhs is a row vector, both vectors
* have the same dimension.
*/
template<class E, class T, std::size_t Sz>
template<class E, class T, int Sz>
inline
typename PromoteTraits<T, typename E::value_type>::value_type
dot(const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) {
@ -611,7 +611,7 @@ cross(const Vector<T1, 3>& lhs, const XprVector<E2, 3>& rhs) {
* |Vector<T, Sz> v| = |v| = \sum_{i=0}^{Sz-1}\,|v[i]|
* \f]
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename NumericTraits<typename E::value_type>::sum_type
norm1(const XprVector<E, Sz>& v) {
@ -632,7 +632,7 @@ norm1(const XprVector<E, Sz>& v) {
*
* \note The internal cast for Vector<int> avoids warnings on sqrt.
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
typename NumericTraits<typename E::value_type>::sum_type
norm2(const XprVector<E, Sz>& v) {
@ -652,7 +652,7 @@ norm2(const XprVector<E, Sz>& v) {
* \frac{Vector<T, Sz> v}{\sqrt{ \sum_{i=0}^{Sz-1}\,v[i]^2 }}
* \f]
*/
template<class E, std::size_t Sz>
template<class E, int Sz>
inline
XprVector<
XprBinOp<

44
tvmet-1.7.1/include/tvmet/xpr/VectorOperators.h
View File

@ -42,7 +42,7 @@ namespace tvmet {
* operator(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -71,7 +71,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, POD) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -84,7 +84,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
POD rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -136,7 +136,7 @@ TVMET_DECLARE_MACRO(div, /, long double)
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -149,7 +149,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -181,7 +181,7 @@ TVMET_DECLARE_MACRO(div, /) // per se element wise
* operator(XprVector, XprVector)
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -223,7 +223,7 @@ TVMET_DECLARE_MACRO(or, ||)
* Note: operations are per se element_wise
*/
#define TVMET_DECLARE_MACRO(NAME, OP, TP) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -236,7 +236,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
TP rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -330,7 +330,7 @@ TVMET_DECLARE_MACRO(not_eq, !=, long double)
* \todo type promotion
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -343,7 +343,7 @@ XprVector< \
operator OP (const XprVector<E, Sz>& lhs, \
const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -380,7 +380,7 @@ TVMET_DECLARE_MACRO(or, ||)
* Unary Operator on XprVector<E, Sz>
*/
#define TVMET_DECLARE_MACRO(NAME, OP) \
template <class E, std::size_t Sz> \
template <class E, int Sz> \
inline \
XprVector< \
XprUnOp< \
@ -413,7 +413,7 @@ TVMET_DECLARE_MACRO(neg, -)
* operator(XprVector<E1, Sz>, XprVector<E2, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -444,7 +444,7 @@ namespace element_wise {
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -458,7 +458,7 @@ operator OP (const XprVector<E, Sz>& lhs, POD rhs) { \
return NAME (lhs, rhs); \
} \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -511,7 +511,7 @@ TVMET_IMPLEMENT_MACRO(div, /, long double)
* Note: operations +,-,*,/ are per se element wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -526,7 +526,7 @@ operator OP (const XprVector<E, Sz>& lhs, \
return NAME (lhs, rhs); \
} \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -560,7 +560,7 @@ TVMET_IMPLEMENT_MACRO(div, /) // per se element wise
* operator(XprVector, XprVector)
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E1, class E2, std::size_t Sz> \
template<class E1, class E2, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -609,7 +609,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* Note: operations are per se element_wise
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -629,7 +629,7 @@ operator OP (const XprVector<E, Sz>& lhs, TP rhs) { \
expr_type(lhs, XprLiteral< TP >(rhs))); \
} \
\
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprBinOp< \
@ -730,7 +730,7 @@ TVMET_IMPLEMENT_MACRO(not_eq, !=, long double)
* \todo type promotion
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -751,7 +751,7 @@ operator OP (const XprVector<E, Sz>& lhs, \
expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \
} \
\
template<class E, std::size_t Sz, class T> \
template<class E, int Sz, class T> \
inline \
XprVector< \
XprBinOp< \
@ -796,7 +796,7 @@ TVMET_IMPLEMENT_MACRO(or, ||)
* Unary Operator on XprVector<E, Sz>
*/
#define TVMET_IMPLEMENT_MACRO(NAME, OP) \
template <class E, std::size_t Sz> \
template <class E, int Sz> \
inline \
XprVector< \
XprUnOp< \

4
tvmet-1.7.1/include/tvmet/xpr/VectorUnaryFunctions.h
View File

@ -35,7 +35,7 @@ namespace tvmet {
* unary_function(XprVector<E, Sz>)
*/
#define TVMET_DECLARE_MACRO(NAME) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprUnOp< \
@ -100,7 +100,7 @@ TVMET_DECLARE_MACRO(finite)
* unary_function(XprVector<E, Sz>)
*/
#define TVMET_IMPLEMENT_MACRO(NAME) \
template<class E, std::size_t Sz> \
template<class E, int Sz> \
inline \
XprVector< \
XprUnOp< \

18
tvmet-1.7.1/tests/swap.cc
View File

@ -16,7 +16,7 @@ using namespace std;
NS_TVMET_BEGIN
template<size_t Sz, size_t Idx=0>
template<int Sz, int Idx=0>
class MetaSwap // later, should be MetaVector
{
private:
@ -47,7 +47,7 @@ public:
* \fun swap
* \brief swaps to vector expressions XprVector<E, Sz>
*/
template<class E1, class E2, size_t Sz>
template<class E1, class E2, int Sz>
inline
void swap(XprVector<E1, Sz> e1, XprVector<E2, Sz> e2) {
MetaSwap<Sz>::swap(e1, e2);
@ -57,7 +57,7 @@ void swap(XprVector<E1, Sz> e1, XprVector<E2, Sz> e2) {
* \fun swap
* \brief swaps to vector
*/
template<class T1, class T2, size_t Sz>
template<class T1, class T2, int Sz>
inline
void swap(Vector<T1, Sz>& lhs, Vector<T2, Sz>& rhs) {
swap(lhs.asXpr(), rhs.asXpr());
@ -68,11 +68,11 @@ void swap(Vector<T1, Sz>& lhs, Vector<T2, Sz>& rhs) {
* \fun swap2
* \brief swaps to vector expressions XprVector<E, Sz>
*/
template<class E1, class E2, size_t Sz>
template<class E1, class E2, int Sz>
inline
void swap2(XprVector<E1, Sz> e1, XprVector<E2, Sz> e2) {
// loops are faster than meta templates
for(size_t i = 0; i < Sz; ++i)
for(int i = 0; i < Sz; ++i)
std::swap(e1[i], e2[i]);
}
@ -80,11 +80,11 @@ void swap2(XprVector<E1, Sz> e1, XprVector<E2, Sz> e2) {
* \fun swap2
* \brief swaps to vector
*/
template<class T1, class T2, size_t Sz>
template<class T1, class T2, int Sz>
inline
void swap2(Vector<T1, Sz>& lhs, Vector<T2, Sz>& rhs) {
// loops are faster than meta templates
for(size_t i = 0; i < Sz; ++i)
for(int i = 0; i < Sz; ++i)
std::swap(lhs[i], rhs[i]);
}
@ -126,11 +126,11 @@ int main() {
cout << "\nSwap Vectors\n\n";
cout << v1 << endl;
cout << v2 << endl;
for(size_t i = 0; i < LOOPS; ++i)
for(int i = 0; i < LOOPS; ++i)
test_meta_swap(v1, v2);
cout << v1 << endl;
cout << v2 << endl;
for(size_t i = 0; i < LOOPS; ++i)
for(int i = 0; i < LOOPS; ++i)
test_loop_swap(v1, v2);
cout << v1 << endl;
cout << v2 << endl;

2
tvmet-1.7.1/tests/t.cc
View File

@ -7,7 +7,7 @@ using std::endl;
struct separator {
std::ostream& print_on(std::ostream& os) const {
for(std::size_t i = 0; i < 63; ++i) os << "-";
for(int i = 0; i < 63; ++i) os << "-";
return os;
}
};

12
tvmet-1.7.1/testsuite/TestConstruction.h
View File

@ -119,7 +119,7 @@ void
TestConstruction<T>::vector_ctor1() {
T data[] = {1,2,3};
std::size_t sz = sizeof(data)/sizeof(T);
int sz = sizeof(data)/sizeof(T);
T* first = data;
T* last = data + sz;
@ -129,14 +129,14 @@ TestConstruction<T>::vector_ctor1() {
}
/*
* Vector (InputIterator first, std::size_t sz)
* Vector (InputIterator first, int sz)
*/
template <class T>
void
TestConstruction<T>::vector_ctor2() {
T data[] = {1,2,3};
std::size_t sz = sizeof(data)/sizeof(T);
int sz = sizeof(data)/sizeof(T);
T* first = data;
vector_type v(first, sz);
@ -220,7 +220,7 @@ TestConstruction<T>::matrix_ctor1() {
2,5,8,
3,6,9 };
std::size_t sz = sizeof(data)/sizeof(T);
int sz = sizeof(data)/sizeof(T);
T* first = data;
T* last = data + sz;
@ -230,7 +230,7 @@ TestConstruction<T>::matrix_ctor1() {
}
/*
* Matrix (InputIterator first, std::size_t sz)
* Matrix (InputIterator first, int sz)
*/
template <class T>
void
@ -239,7 +239,7 @@ TestConstruction<T>::matrix_ctor2() {
2,5,8,
3,6,9 };
std::size_t sz = sizeof(data)/sizeof(T);
int sz = sizeof(data)/sizeof(T);
T* first = data;
matrix_type m(first, sz);

22
tvmet-1.7.1/testsuite/TestUnloops.h
View File

@ -110,9 +110,9 @@ void TestUnloops<T>::mv_product(const LHS& A, const RHS& B, RES& X) {
N = RHS::Size // is Vector
};
for (std::size_t i = 0; i < M; i++){
for (int i = 0; i < M; i++){
value_type sum(0);
for (std::size_t j = 0; j < N; j++){
for (int j = 0; j < N; j++){
sum += A(i, j) * B(j);
}
X(i) = sum;
@ -132,10 +132,10 @@ void TestUnloops<T>::mm_product(const LHS& A, const RHS& B, RES& X) {
K = RHS::Rows
};
for (std::size_t i = 0; i < M; ++i) {
for (std::size_t j = 0; j < N; ++j) {
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
value_type sum(0);
for (std::size_t k = 0; k < K; ++k) {
for (int k = 0; k < K; ++k) {
sum += A(i, k) * B(k, j);
}
X(i, j) = sum;
@ -156,10 +156,10 @@ void TestUnloops<T>::mtm_product(const LHS& A, const RHS& B, RES& X) {
K = RHS::Rows
};
for (std::size_t i = 0; i < N; i++){
for (std::size_t j = 0; j < N; j++){
for (int i = 0; i < N; i++){
for (int j = 0; j < N; j++){
value_type sum(0);
for (std::size_t k = 0; k < K; k++){
for (int k = 0; k < K; k++){
sum += A(k, i) * B(k, j);
}
X(i, j) = sum;
@ -180,10 +180,10 @@ void TestUnloops<T>::mmt_product(const LHS& A, const RHS& B, RES& X) {
K = LHS::Cols
};
for (std::size_t i = 0;i < N; i++){
for (std::size_t j = 0;j < N; j++){
for (int i = 0;i < N; i++){
for (int j = 0;j < N; j++){
value_type sum(0);
for (std::size_t k = 0;k < N; k++){
for (int k = 0;k < N; k++){
sum += A(i, k)*A(j, k);
}
X(i, j) = sum;