/*! * \file * \brief Templated Vector Class Definitions * \author Tony Ottosson, Tobias Ringstrom, Adam Piatyszek and Conrad Sanderson * * ------------------------------------------------------------------------- * * IT++ - C++ library of mathematical, signal processing, speech processing, * and communications classes and functions * * Copyright (C) 1995-2007 (see AUTHORS file for a list of contributors) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * ------------------------------------------------------------------------- */ #ifndef VEC_H #define VEC_H #ifndef _MSC_VER # include #else # include #endif #include #include #include #include namespace itpp { // Declaration of Vec template class Vec; // Declaration of Mat template class Mat; // Declaration of bin class bin; //----------------------------------------------------------------------------------- // Declaration of Vec Friends //----------------------------------------------------------------------------------- //! Addition of two vectors template const Vec operator+(const Vec &v1, const Vec &v2); //! Addition of a vector and a scalar template const Vec operator+(const Vec &v, const Num_T t); //! Addition of a scalar and a vector template const Vec operator+(const Num_T t, const Vec &v); //! Subtraction of a vector from a vector template const Vec operator-(const Vec &v1, const Vec &v2); //! Subtraction of a scalar from a vector template const Vec operator-(const Vec &v, const Num_T t); //! Subtraction of vector from scalar. Results in a vector template const Vec operator-(const Num_T t, const Vec &v); //! Negation of vector template const Vec operator-(const Vec &v); //! Inner (dot) product of two vectors v1 and v2 template Num_T dot(const Vec &v1, const Vec &v2); //! Inner (dot) product of two vectors v1 and v2 template Num_T operator*(const Vec &v1, const Vec &v2); /*! * \brief Outer product of two vectors v1 and v2 * * When \a v1 and \a v2 are complex vectors (cvec), the third boolean * argument \a hermitian can be set to \a true to conjugate \a v2 * (Matlab's v1 * v2' operation). This parameter is ignored for types * other then cvec. */ template const Mat outer_product(const Vec &v1, const Vec &v2, bool hermitian = false); //! Multiplication of a vector and a scalar template const Vec operator*(const Vec &v, const Num_T t); //! Multiplication of a scalar and a vector. Results in a vector template const Vec operator*(const Num_T t, const Vec &v); //! Element-wise multiplication of the two vectors. Same functionality as Matlab/Octave expression a .* b template const Vec elem_mult(const Vec &a, const Vec &b); //! Element-wise multiplication of the three vectors template const Vec elem_mult(const Vec &a, const Vec &b, const Vec &c); //! Element-wise multiplication of the four vectors template const Vec elem_mult(const Vec &a, const Vec &b, const Vec &c, const Vec &d); //! Element-wise multiplication of the two vectors, storing the result in vector \c out (which is re-sized if necessary) template void elem_mult_out(const Vec &a, const Vec &b, Vec &out); //! Element-wise multiplication of the three vectors, storing the result in vector \c out (which is re-sized if necessary) template void elem_mult_out(const Vec &a, const Vec &b, const Vec &c, Vec &out); //! Element-wise multiplication of the four vectors, storing the result in vector \c out (which is re-sized if necessary) template void elem_mult_out(const Vec &a, const Vec &b, const Vec &c, const Vec &d, Vec &out); //! In-place element-wise multiplication of two vectors. Fast version of b = elem_mult(a,b) template void elem_mult_inplace(const Vec &a, Vec &b); //! Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b)) template Num_T elem_mult_sum(const Vec &a, const Vec &b); //! Division of all elements in \c v with \c t template const Vec operator/(const Vec &v, const Num_T t); //! Division of \c t with all elements in \c v template const Vec operator/(const Num_T t, const Vec &v); //! Elementwise division of two vectors. Same functionality as Matlab/Octave expression a ./ b template const Vec elem_div(const Vec &a, const Vec &b); //! Elementwise division of scalar \c t and vector \c v template const Vec elem_div(const Num_T t, const Vec &v); //! Elementwise division of two vectors, storing the result in vector \c out (which is re-sized if necessary) template void elem_div_out(const Vec &a, const Vec &b, Vec &out); //! Elementwise division of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_div(a,b)) template Num_T elem_div_sum(const Vec &a, const Vec &b); //! Append element \c a to the end of the vector \c v template const Vec concat(const Vec &v, const Num_T a); //! Concat element \c a to the beginning of the vector \c v template const Vec concat(const Num_T a, const Vec &v); //! Concat vectors \c v1 and \c v2 template const Vec concat(const Vec &v1,const Vec &v2); //! Concat vectors \c v1, \c v2 and \c v3 template const Vec concat(const Vec &v1, const Vec &v2, const Vec &v3); //! Concat vectors \c v1, \c v2, \c v3 and \c v4 template const Vec concat(const Vec &v1, const Vec &v2, const Vec &v3, const Vec &v4); //! Concat vectors \c v1, \c v2 \c v3, \c v4 and \c v5 template const Vec concat(const Vec &v1, const Vec &v2, const Vec &v3, const Vec &v4, const Vec &v5); //----------------------------------------------------------------------------------- // Declaration of Vec //----------------------------------------------------------------------------------- /*! \ingroup arr_vec_mat \brief Vector Class (Templated) \author Tony Ottosson, Tobias Ringstrom, Adam Piatyszek and Conrad Sanderson Vectors can be of arbitrarily types, but conversions and functions are prepared for \c bin, \c short, \c int, \c double, and \c complex vectors and these are predefined as: \c bvec, \c svec, \c ivec, \c vec, and \c cvec. \c double and \c complex are \c double and \c complex respectively. Examples: Vector Constructors: When constructing a vector without a length (memory) use \code vec temp; \endcode For construction of a vector of a given length use \code vec temp(length); \endcode It is also possible to assign the constructed vector the value and size of another vector by \code vec temp(invector); \endcode If you have explicit values you would like to assign to the vector it is possible to do this using strings as: \code vec a("0 0.7 5 9.3"); // that is a = [0, 0.7, 5, 9.3] vec a="0 0.7 5 9.3"; // the constructor are called implicitly ivec b="0:5"; // that is b = [0, 1, 2, 3, 4, 5] vec c="3:2.5:13"; // that is c = [3, 5.5, 8, 10.5, 13] \endcode It is also possible to change length by \code temp.set_size(new_length, false); \endcode where \c false is used to indicate that the old values in \c temp is not copied. If you like to preserve the values use \c true. There are a number of methods to access parts of a vector. Examples are \code a(5); // Element number 5 a(5,9); // Elements 5, 6, 7, 8, and 9 a.left(10); // The 10 most left elements (the first) a.right(10); // The 10 most right elements (the last) a.mid(5, 7); // 7 elements starting from element 5 \endcode It is also possible to modify parts of a vector as e.g. in \code a.del(5); // deletes element number 5 a.ins(3.4, 9); // inserts the element 3.4 at position 9 a.replace_mid(12, b); // replaces elements from 12 with the vector b \endcode It is of course also possible to perform the common linear algebra methods such as addition, subtraction, and scalar product (*). Observe though, that vectors are assumed to be column-vectors in operations with matrices. Most elementary functions such as sin(), cosh(), log(), abs(), ..., are available as operations on the individual elements of the vectors. Please see the individual functions for more details. By default, the Vec elements are created using the default constructor for the element type. This can be changed by specifying a suitable Factory in the Vec constructor call; see Detailed Description for Factory. */ template class Vec { public: //! The type of the vector values typedef Num_T value_type; //! Default constructor. An element factory \c f can be specified. explicit Vec(const Factory &f = DEFAULT_FACTORY); //! Constructor with size parameter. An element factory \c f can be specified. explicit Vec(int size, const Factory &f = DEFAULT_FACTORY); //! Copy constructor Vec(const Vec &v); //! Copy constructor, which takes an element factory \c f as an additional argument. Vec(const Vec &v, const Factory &f); //! Constructor taking a char string as input. An element factory \c f can be specified. Vec(const char *values, const Factory &f = DEFAULT_FACTORY); //! Constructor taking a string as input. An element factory \c f can be specified. Vec(const std::string &values, const Factory &f = DEFAULT_FACTORY); //! Constructor taking a C-array as input. Copies all data. An element factory \c f can be specified. Vec(const Num_T *c_array, int size, const Factory &f = DEFAULT_FACTORY); //! Destructor ~Vec(); //! The size of the vector int length() const { return datasize; } //! The size of the vector int size() const { return datasize; } //! Set length of vector. if copy = true then keeping the old values void set_size(int size, const bool copy=false); //! Set length of vector. if copy = true then keeping the old values void set_length(int size, const bool copy=false) { set_size(size, copy); } //! Set the vector to the all zero vector void zeros(); //! Set the vector to the all zero vector void clear() { zeros(); } //! Set the vector to the all one vector void ones(); //! Set the vector equal to the values in the \c str string void set(const char *str); //! Set the vector equal to the values in the \c str string void set(const std::string &str); //! C-style index operator. First element is 0 const Num_T &operator[](int i) const; //! Index operator. First element is 0 const Num_T &operator()(int i) const; //! C-style index operator. First element is 0 Num_T &operator[](int i); //! Index operator. First element is 0 Num_T &operator()(int i); //! Sub-vector with elements from \c i1 to \c i2. Index -1 indicates the last element. const Vec operator()(int i1, int i2) const; //! Sub-vector where the elements are given by the list \c indexlist const Vec operator()(const Vec &indexlist) const; //! Accessor-style method. First element is 0 const Num_T &get(int i) const; //! Sub-vector with elements from \c i1 to \c i2. Index -1 indicates the last element. const Vec get(int i1, int i2) const; //! Modifier-style method. First element is 0 void set(int i, const Num_T &v); //! Matrix transpose. Converts to a matrix with the vector in the first row Mat transpose() const; //! Matrix transpose. Converts to a matrix with the vector in the first row Mat T() const { return this->transpose(); } //! Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row Mat hermitian_transpose() const; //! Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row Mat H() const { return this->hermitian_transpose(); } //! Addition of vector Vec& operator+=(const Vec &v); //! Addition of scalar Vec& operator+=(const Num_T t); //! Addition of two vectors friend const Vec operator+<>(const Vec &v1, const Vec &v2); //! Addition of a vector and a scalar friend const Vec operator+<>(const Vec &v, const Num_T t); //! Addition of a scalar and a vector friend const Vec operator+<>(const Num_T t, const Vec &v); //! Subtraction of vector Vec& operator-=(const Vec &v); //! Subtraction of scalar Vec& operator-=(const Num_T t); //! Subtraction of \c v2 from \c v1 friend const Vec operator-<>(const Vec &v1, const Vec &v2); //! Subtraction of scalar from vector friend const Vec operator-<>(const Vec &v, const Num_T t); //! Sutraction of vector from scalar friend const Vec operator-<>(const Num_T t, const Vec &v); //! Negation of vector friend const Vec operator-<>(const Vec &v); //! Multiply with a scalar Vec& operator*=(const Num_T t); //! Inner (dot) product friend Num_T operator*<>(const Vec &v1, const Vec &v2); //! Inner (dot) product friend Num_T dot <>(const Vec &v1, const Vec &v2); //! Outer product of two vectors v1 and v2 friend const Mat outer_product <>(const Vec &v1, const Vec &v2, bool hermitian); //! Elementwise multiplication of vector and scalar friend const Vec operator*<>(const Vec &v, const Num_T t); //! Elementwise multiplication of vector and scalar friend const Vec operator*<>(const Num_T t, const Vec &v); //! Elementwise multiplication friend const Vec elem_mult <>(const Vec &a, const Vec &b); //! Elementwise multiplication of three vectors friend const Vec elem_mult <>(const Vec &a, const Vec &b, const Vec &c); //! Elementwise multiplication of four vectors friend const Vec elem_mult <>(const Vec &a, const Vec &b, const Vec &c, const Vec &d); //! Elementwise multiplication, storing the result in vector \c out (which is re-sized if necessary) friend void elem_mult_out <>(const Vec &a, const Vec &b, Vec &out); //! Elementwise multiplication of three vectors, storing the result in vector \c out (which is re-sized if necessary) friend void elem_mult_out <>(const Vec &a, const Vec &b, const Vec &c, Vec &out); //! Elementwise multiplication of four vectors, storing the result in vector \c out (which is re-sized if necessary) friend void elem_mult_out <>(const Vec &a, const Vec &b, const Vec &c, const Vec &d, Vec &out); //! In-place element-wise multiplication of two vectors. Fast version of b = elem_mult(a,b) friend void elem_mult_inplace <>(const Vec &a, Vec &b); //! Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b)) friend Num_T elem_mult_sum <>(const Vec &a, const Vec &b); //! Elementwise division Vec& operator/=(const Num_T t); //! Elementwise division Vec& operator/=(const Vec &v); //! Elementwise division friend const Vec operator/<>(const Vec &v, const Num_T t); //! Elementwise division friend const Vec operator/<>(const Num_T t, const Vec &v); //! Elementwise division friend const Vec elem_div <>(const Vec &v1, const Vec &v2); //! Elementwise division friend const Vec elem_div <>(const Num_T t, const Vec &v); //! Elementwise division friend void elem_div_out <>(const Vec &v1, const Vec &v2, Vec &out); //! Elementwise division, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b)) friend Num_T elem_div_sum <>(const Vec &a, const Vec &b); //! Get the elements in the vector where \c binlist is \c 1 Vec get(const Vec &binlist) const; //! Get the right \c nr elements from the vector Vec right(int nr) const; //! Get the left \c nr elements from the vector Vec left(int nr) const; //! Get the middle part of vector from \c start including \c nr elements Vec mid(int start, int nr) const; //! Split the vector into two parts at element \c pos. Return the first part and keep the second. Vec split(int pos); //! Shift in element \c In at position 0 \c n times void shift_right(const Num_T In, int n=1); //! Shift in vector \c In at position 0 void shift_right(const Vec &In); //! Shift out the \c n left elements and a the same time shift in the element \c at last position \c n times void shift_left(const Num_T In, int n=1); //! Shift in vector \c In at last position void shift_left(const Vec &In); //! Append element \c a to the end of the vector \c v friend const Vec concat<>(const Vec &v, const Num_T a); //! Concat element \c a to the beginning of the vector \c v friend const Vec concat<>(const Num_T a, const Vec &v); //! Concat vectors \c v1 and \c v2 friend const Vec concat<>(const Vec &v1,const Vec &v2); //! Concat vectors \c v1, \c v2 and \c v3 friend const Vec concat<>(const Vec &v1, const Vec &v2, const Vec &v3); //! Concat vectors \c v1, \c v2, \c v3 and \c v4 friend const Vec concat<>(const Vec &v1, const Vec &v2, const Vec &v3, const Vec &v4); //! Concat vectors \c v1, \c v2, \c v3, \c v4 and \c v5 friend const Vec concat<>(const Vec &v1, const Vec &v2, const Vec &v3, const Vec &v4, const Vec &v5); //! Set subvector defined by indicies \c i1 to \c i2 to vector \c v void set_subvector(int i1, int i2, const Vec &v); //! Set subvector defined by first index \c i and size of vector \c v to \c v void set_subvector(int i, const Vec &v); //! Set subvector defined by indicies i1 to i2 to constant t void set_subvector(int i1, int i2, const Num_T t); //! Replace the elements from \c pos by the vector \c v void replace_mid(int pos, const Vec &v); //! Delete element number \c index void del(int index); //! Delete elements from \c i1 to \c i2 void del(int i1, int i2); //! Insert element \c in at \c index void ins(int index, const Num_T in); //! Insert vector \c in at \c index void ins(int index, const Vec &in); //! Assign all elements in vector to \c t Vec& operator=(const Num_T t); //! Assign vector the value and length of \c v Vec& operator=(const Vec &v); //! Assign vector equal to the 1-dimensional matrix \c m Vec& operator=(const Mat &m); //! Assign vector the values in the string \c values Vec& operator=(const char *values); //! Elementwise equal to the scalar Vec operator==(const Num_T value) const; //! Elementwise not-equal to the scalar Vec operator!=(const Num_T value) const; //! Elementwise less than the scalar Vec operator<(const Num_T value) const; //! Elementwise less than and equal to the scalar Vec operator<=(const Num_T value) const; //! Elementwise greater than the scalar Vec operator>(const Num_T value) const; //! Elementwise greater than and equal to the scalar Vec operator>=(const Num_T value) const; //! Compare two vectors. False if wrong sizes or different values bool operator==(const Vec &v) const; //! Compare two vectors. True if different bool operator!=(const Vec &v) const; //! Index operator without boundary check. Not recommended to use. Num_T &_elem(int i) { return data[i]; } //! Index operator without boundary check. Not recommended to use. const Num_T &_elem(int i) const { return data[i]; } //! Get the pointer to the internal structure. Not recommended to use. Num_T *_data() { return data; } //! Get the pointer to the internal structure. Not recommended to use. const Num_T *_data() const { return data; } protected: //! Allocate storage for a vector of length \c size. void alloc(int size); //! Free the storage space allocated by the vector void free(); //! The current number of elements in the vector int datasize; //! A pointer to the data area Num_T *data; //! Element factory (set to DEFAULT_FACTORY to use Num_T default constructors only) const Factory &factory; private: // This function is used in set() methods to replace commas with spaces std::string replace_commas(const std::string &str); }; //----------------------------------------------------------------------------------- // Type definitions of vec, cvec, ivec, svec, and bvec //----------------------------------------------------------------------------------- /*! \relates Vec \brief Definition of double vector type */ typedef Vec vec; /*! \relates Vec \brief Definition of complex vector type */ typedef Vec > cvec; /*! \relates Vec \brief Definition of integer vector type */ typedef Vec ivec; /*! \relates Vec \brief Definition of short vector type */ typedef Vec svec; /*! \relates Vec \brief Definition of binary vector type */ typedef Vec bvec; } //namespace itpp #include namespace itpp { //----------------------------------------------------------------------------------- // Declaration of input and output streams for Vec //----------------------------------------------------------------------------------- /*! \relates Vec \brief Stream output of vector */ template std::ostream &operator<<(std::ostream &os, const Vec &v); /*! \relates Vec \brief Stream input of vector The input can be on the form "1 2 3" or "[1 2 3]", i.e. with or without brackets. The first form is compatible with the set method, while the second form is compatible with the ostream operator. The elements can be separated by blank space or commas. "[]" means an empty vector. "1:4" means "1 2 3 4". "1:3:10" means every third integer from 1 to 10, i.e. "1 4 7 10". */ template std::istream &operator>>(std::istream &is, Vec &v); //----------------------------------------------------------------------------------- // Implementation of templated Vec members and friends //----------------------------------------------------------------------------------- template inline void Vec::alloc(int size) { if (size > 0) { create_elements(data, size, factory); datasize = size; } else { data = 0; datasize = 0; } } template inline void Vec::free() { destroy_elements(data, datasize); datasize = 0; } template inline Vec::Vec(const Factory &f) : datasize(0), data(0), factory(f) {} template inline Vec::Vec(int size, const Factory &f) : datasize(0), data(0), factory(f) { it_assert_debug(size>=0, "Negative size in Vec::Vec(int)"); alloc(size); } template inline Vec::Vec(const Vec &v) : datasize(0), data(0), factory(v.factory) { alloc(v.datasize); copy_vector(datasize, v.data, data); } template inline Vec::Vec(const Vec &v, const Factory &f) : datasize(0), data(0), factory(f) { alloc(v.datasize); copy_vector(datasize, v.data, data); } template inline Vec::Vec(const char *values, const Factory &f) : datasize(0), data(0), factory(f) { set(values); } template inline Vec::Vec(const std::string &values, const Factory &f) : datasize(0), data(0), factory(f) { set(values); } template inline Vec::Vec(const Num_T *c_array, int size, const Factory &f) : datasize(0), data(0), factory(f) { alloc(size); copy_vector(size, c_array, data); } template inline Vec::~Vec() { free(); } template void Vec::set_size(int size, bool copy) { it_assert_debug(size >= 0, "Vec::set_size(): New size must not be negative"); if (datasize == size) return; if (copy) { // create a temporary pointer to the allocated data Num_T* tmp = data; // store the current number of elements int old_datasize = datasize; // check how many elements we need to copy int min = datasize < size ? datasize : size; // allocate new memory alloc(size); // copy old elements into a new memory region copy_vector(min, tmp, data); // initialize the rest of resized vector for (int i = min; i < size; ++i) data[i] = Num_T(0); // delete old elements destroy_elements(tmp, old_datasize); } else { free(); alloc(size); } } template inline const Num_T& Vec::operator[](int i) const { it_assert_debug((i >= 0) && (i < datasize), "Vec::operator[]: Index out of range"); return data[i]; } template inline const Num_T& Vec::operator()(int i) const { it_assert_debug((i >= 0) && (i < datasize), "Vec::operator(): Index out of range"); return data[i]; } template inline Num_T& Vec::operator[](int i) { it_assert_debug((i >= 0) && (i < datasize), "Vec::operator[]: Index out of range"); return data[i]; } template inline Num_T& Vec::operator()(int i) { it_assert_debug((i >= 0) && (i < datasize), "Vec::operator(): Index out of range"); return data[i]; } template inline const Vec Vec::operator()(int i1, int i2) const { int ii1=i1, ii2=i2; if (ii1 == -1) ii1 = datasize-1; if (ii2 == -1) ii2 = datasize-1; it_assert_debug(ii1>=0 && ii2>=0 && ii1=ii1, "Vec::op(i1,i2): i2 >= i1 necessary"); Vec s(ii2-ii1+1); copy_vector(s.datasize, data+ii1, s.data); return s; } template const Vec Vec::operator()(const Vec &indexlist) const { Vec temp(indexlist.length()); for (int i=0;i=0) && (indexlist(i) < datasize), "Vec::operator()(ivec &): index outside range"); temp(i)=data[indexlist(i)]; } return temp; } template inline const Num_T& Vec::get(int i) const { it_assert_debug((i >= 0) && (i < datasize), "method get()"); return data[i]; } template inline const Vec Vec::get(int i1, int i2) const { return (*this)(i1, i2); } template inline void Vec::zeros() { for (int i = 0; i < datasize; i++) data[i] = Num_T(0); } template inline void Vec::ones() { for (int i = 0; i < datasize; i++) data[i] = Num_T(1); } template inline void Vec::set(int i, const Num_T &v) { it_assert_debug((i >= 0) && (i < datasize), "method set()"); data[i] = v; } //! \cond template<> void Vec::set(const std::string &str); template<> void Vec >::set(const std::string &str); template<> void Vec::set(const std::string &str); template<> void Vec::set(const std::string &str); template<> void Vec::set(const std::string &str); //! \endcond template void Vec::set(const std::string &str) { it_error("Vec::set(): Only `double', `complex', `int', " "`short int' and `bin' types supported"); } template void Vec::set(const char *str) { set(std::string(str)); } template Mat Vec::transpose() const { Mat temp(1, datasize); copy_vector(datasize, data, temp._data()); return temp; } template<> Mat > Vec >::hermitian_transpose() const; template Mat Vec::hermitian_transpose() const { Mat temp(1, datasize); copy_vector(datasize, data, temp._data()); return temp; } template inline Vec& Vec::operator+=(const Vec &v) { if (datasize == 0) { // if not assigned a size. if (this != &v) { // check for self addition alloc(v.datasize); copy_vector(datasize, v.data, data); } } else { it_assert_debug(datasize == v.datasize, "Vec::operator+=: Wrong sizes"); for (int i = 0; i < datasize; i++) data[i] += v.data[i]; } return *this; } template inline Vec& Vec::operator+=(const Num_T t) { for (int i=0;i inline const Vec operator+(const Vec &v1, const Vec &v2) { int i; Vec r(v1.datasize); it_assert_debug(v1.datasize==v2.datasize, "Vec::operator+: wrong sizes"); for (i=0; i inline const Vec operator+(const Vec &v, const Num_T t) { int i; Vec r(v.datasize); for (i=0; i inline const Vec operator+(const Num_T t, const Vec &v) { int i; Vec r(v.datasize); for (i=0; i inline Vec& Vec::operator-=(const Vec &v) { if (datasize == 0) { // if not assigned a size. if (this != &v) { // check for self decrementation alloc(v.datasize); for (int i = 0; i < v.datasize; i++) data[i] = -v.data[i]; } } else { it_assert_debug(datasize == v.datasize, "Vec::operator-=: Wrong sizes"); for (int i = 0; i < datasize; i++) data[i] -= v.data[i]; } return *this; } template inline Vec& Vec::operator-=(const Num_T t) { for (int i=0;i inline const Vec operator-(const Vec &v1, const Vec &v2) { int i; Vec r(v1.datasize); it_assert_debug(v1.datasize==v2.datasize, "Vec::operator-: wrong sizes"); for (i=0; i inline const Vec operator-(const Vec &v, const Num_T t) { int i; Vec r(v.datasize); for (i=0; i inline const Vec operator-(const Num_T t, const Vec &v) { int i; Vec r(v.datasize); for (i=0; i inline const Vec operator-(const Vec &v) { int i; Vec