/*---------------------------------------------------------------------------*
* IT++ *
*---------------------------------------------------------------------------*
* Copyright (c) 1995-2004 by Tony Ottosson, Thomas Eriksson, Pål Frenger, *
* Tobias Ringström, and Jonas Samuelsson. *
* *
* Permission to use, copy, modify, and distribute this software and its *
* documentation under the terms of the GNU General Public License is hereby *
* granted. No representations are made about the suitability of this *
* software for any purpose. It is provided "as is" without expressed or *
* implied warranty. See the GNU General Public License for more details. *
*---------------------------------------------------------------------------*/
/*!
\file
\brief Templated Vector Class Implementation
\author Tony Ottosson and Tobias Ringström
1.45
2004/09/05 03:32:18
*/
#include "base/vec.h"
#ifndef NO_CBLAS
#include "base/cblas.h"
#endif
namespace itpp {
template<>
bool cvec::set(const char *values)
{
istringstream buffer(values);
int pos=0, maxpos=10;
alloc(maxpos);
while (buffer.peek()!=EOF) {
switch (buffer.peek()) {
case ':':
it_error("set: expressions with ':' are not valid for cvec");
break;
case ',':
buffer.get();
break;
default:
pos++;
if (pos > maxpos) {
maxpos *= 2;
set_size(maxpos, true);
}
buffer >> data[pos-1];
while (buffer.peek()==' ') { buffer.get(); }
break;
}
}
set_size(pos, true);
return true;
}
template<>
bool bvec::set(const char *values)
{
std::istringstream buffer(values);
int pos=0, maxpos=10;
short intemp;
alloc(maxpos);
while (buffer.peek()!=EOF) {
if (buffer.peek()==',') {
buffer.get();
} else {
pos++;
if (pos > maxpos) {
maxpos=maxpos*2;
set_size(maxpos, true);
}
buffer >> intemp;
data[pos-1]=intemp;
while (buffer.peek()==' ') { buffer.get(); }
}
}
set_size(pos, true);
return true;
}
#ifndef NO_CBLAS
template<>
double dot(const vec &v1, const vec &v2)
{
it_assert1(v1.datasize==v2.datasize, "vec::dot: wrong sizes");
double r=0.0;
r= cblas_ddot(v1.datasize, v1.data, 1, v2.data, 1);
return r;
}
template<>
complex<double> dot(const cvec &v1, const cvec &v2)
{
it_assert1(v1.datasize==v2.datasize, "cvec::dot: wrong sizes");
complex<double> r=0.0;
cblas_zdotu_sub(v1.datasize, v1.data, 1, v2.data, 1, &r);
return r;
}
#endif //NO_CBLAS
template<>
bvec cvec::operator==(const complex<double>) const
{
it_error("operator==: not implemented for complex");
bvec temp;
return temp;
}
template<>
bvec cvec::operator!=(const complex<double>) const
{
it_error("operator!=: not implemented for complex");
bvec temp;
return temp;
}
template<>
bvec cvec::operator<=(const complex<double>) const
{
it_error("operator<=: not implemented for complex");
bvec temp;
return temp;
}
template<>
bvec cvec::operator>(const complex<double>) const
{
it_error("operator>: not implemented for complex");
bvec temp;
return temp;
}
template<>
bvec cvec::operator<(const complex<double>) const
{
it_error("operator<: not implemented for complex");
bvec temp;
return temp;
}
template<>
bvec cvec::operator>=(const complex<double>) const
{
it_error("operator>=: not implemented for complex");
bvec temp;
return temp;
}
template<>
Mat<complex<double> > cvec::hermitian_transpose() const
{
Mat<complex<double> > temp(1, datasize);
for (int i=0; i<datasize; i++)
temp(i) = std::conj(data[i]);
return temp;
}
//---------------------------------------------------------------------
// Instantiations
//---------------------------------------------------------------------
//--------- class instantiations -------------
//! Template instantiation of Vec<double>
template class Vec<double>;
//! Template instantiation of Vec<int>
template class Vec<int>;
//! Template instantiation of Vec<short int>
template class Vec<short int>;
//! Template instantiation of Vec<complex<double> >
template class Vec<complex<double> >;
//! Template instantiation of Vec<bin>
template class Vec<bin>;
//------------- Addition operator ----------
//! Template instantiation of operator+
template vec operator+(const vec &v1, const vec &v2);
//! Template instantiation of operator+
template cvec operator+(const cvec &v1, const cvec &v2);
//! Template instantiation of operator+
template ivec operator+(const ivec &v1, const ivec &v2);
//! Template instantiation of operator+
template svec operator+(const svec &v1, const svec &v2);
//! Template instantiation of operator+
template bvec operator+(const bvec &v1, const bvec &v2);
//! Template instantiation of operator+
template vec operator+(const vec &v1, double t);
//! Template instantiation of operator+
template cvec operator+(const cvec &v1, complex<double> t);
//! Template instantiation of operator+
template ivec operator+(const ivec &v1, int t);
//! Template instantiation of operator+
template svec operator+(const svec &v1, short t);
//! Template instantiation of operator+
template bvec operator+(const bvec &v1, bin t);
//! Template instantiation of operator+
template vec operator+(double t, const vec &v1);
//! Template instantiation of operator+
template cvec operator+(complex<double> t, const cvec &v1);
//! Template instantiation of operator+
template ivec operator+(int t, const ivec &v1);
//! Template instantiation of operator+
template svec operator+(short t, const svec &v1);
//! Template instantiation of operator+
template bvec operator+(bin t, const bvec &v1);
//------------- Subraction operator ----------
//! Template instantiation of operator-
template vec operator-(const vec &v1, const vec &v2);
//! Template instantiation of operator-
template cvec operator-(const cvec &v1, const cvec &v2);
//! Template instantiation of operator-
template ivec operator-(const ivec &v1, const ivec &v2);
//! Template instantiation of operator-
template svec operator-(const svec &v1, const svec &v2);
//! Template instantiation of operator-
template bvec operator-(const bvec &v1, const bvec &v2);
//! Template instantiation of operator-
template vec operator-(const vec &v, double t);
//! Template instantiation of operator-
template cvec operator-(const cvec &v, complex<double> t);
//! Template instantiation of operator-
template ivec operator-(const ivec &v, int t);
//! Template instantiation of operator-
template svec operator-(const svec &v, short t);
//! Template instantiation of operator-
template bvec operator-(const bvec &v, bin t);
//! Template instantiation of operator-
template vec operator-(double t, const vec &v);
//! Template instantiation of operator-
template cvec operator-(complex<double> t, const cvec &v);
//! Template instantiation of operator-
template ivec operator-(int t, const ivec &v);
//! Template instantiation of operator-
template svec operator-(short t, const svec &v);
//! Template instantiation of operator-
template bvec operator-(bin t, const bvec &v);
//---------- Unary minus -------------
//! Template instantiation of operator-
template vec operator-(const vec &v);
//! Template instantiation of operator-
template cvec operator-(const cvec &v);
//! Template instantiation of operator-
template ivec operator-(const ivec &v);
//! Template instantiation of operator-
template svec operator-(const svec &v);
//! Template instantiation of operator-
template bvec operator-(const bvec &v);
//------------- Multiplication operator ----------
#ifdef NO_CBLAS
//! Template instantiation of dot
template double dot(const vec &v1, const vec &v2);
//! Template instantiation of dot
template complex<double> dot(const cvec &v1, const cvec &v2);
#endif
//! Template instantiation of dot
template int dot(const ivec &v1, const ivec &v2);
//! Template instantiation of dot
template short dot(const svec &v1, const svec &v2);
//! Template instantiation of dot
template bin dot(const bvec &v1, const bvec &v2);
//! Template instantiation of operator*
template int operator*(const ivec &v1, const ivec &v2);
//! Template instantiation of operator*
template short operator*(const svec &v1, const svec &v2);
//! Template instantiation of operator*
template bin operator*(const bvec &v1, const bvec &v2);
//! Template instantiation of outer_product
template mat outer_product(const vec &v1, const vec &v2);
//! Template instantiation of outer_product
template cmat outer_product(const cvec &v1, const cvec &v2);
//! Template instantiation of outer_product
template imat outer_product(const ivec &v1, const ivec &v2);
//! Template instantiation of outer_product
template smat outer_product(const svec &v1, const svec &v2);
//! Template instantiation of outer_product
template bmat outer_product(const bvec &v1, const bvec &v2);
//! Template instantiation of operator*
template vec operator*(const vec &v, double t);
//! Template instantiation of operator*
template cvec operator*(const cvec &v, complex<double> t);
//! Template instantiation of operator*
template ivec operator*(const ivec &v, int t);
//! Template instantiation of operator*
template svec operator*(const svec &v, short t);
//! Template instantiation of operator*
template bvec operator*(const bvec &v, bin t);
//! Template instantiation of operator*
template vec operator*(double t, const vec &v);
//! Template instantiation of operator*
template cvec operator*(complex<double> t, const cvec &v);
//! Template instantiation of operator*
template ivec operator*(int t, const ivec &v);
//! Template instantiation of operator*
template svec operator*(short t, const svec &v);
//! Template instantiation of operator*
template bvec operator*(bin t, const bvec &v);
//------------- Elementwise Multiplication operator (two vectors) ----------
//! Template instantiation of elem_mult
template vec elem_mult(const vec &v1, const vec &v2);
//! Template instantiation of elem_mult
template cvec elem_mult(const cvec &v1, const cvec &v2);
//! Template instantiation of elem_mult
template ivec elem_mult(const ivec &v1, const ivec &v2);
//! Template instantiation of elem_mult
template svec elem_mult(const svec &v1, const svec &v2);
//! Template instantiation of elem_mult
template bvec elem_mult(const bvec &v1, const bvec &v2);
//------------- Elementwise Multiplication operator (three vectors) ----------
//! Template instantiation of elem_mult
template vec elem_mult(const vec &v1, const vec &v2, const vec &v3);
//! Template instantiation of elem_mult
template cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3);
//! Template instantiation of elem_mult
template ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3);
//! Template instantiation of elem_mult
template svec elem_mult(const svec &v1, const svec &v2, const svec &v3);
//! Template instantiation of elem_mult
template bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3);
//------------- Elementwise Multiplication operator (four vectors) ----------
//! Template instantiation of elem_mult
template vec elem_mult(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
//! Template instantiation of elem_mult
template cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
//! Template instantiation of elem_mult
template ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
//! Template instantiation of elem_mult
template svec elem_mult(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
//! Template instantiation of elem_mult
template bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
//------------- Division operator ----------
//! Template instantiation of operator/
template vec operator/(const vec &v, double t);
//! Template instantiation of operator/
template cvec operator/(const cvec &v, complex<double> t);
//! Template instantiation of operator/
template ivec operator/(const ivec &v, int t);
//! Template instantiation of operator/
template svec operator/(const svec &v, short t);
//! Template instantiation of operator/
template bvec operator/(const bvec &v, bin t);
//! Template instantiation of operator/
template vec operator/(const double t, const vec &v);
//! Template instantiation of operator/
template cvec operator/(const complex<double> t, const cvec &v);
//! Template instantiation of operator/
template ivec operator/(const int t, const ivec &v);
//! Template instantiation of operator/
template svec operator/(const short t, const svec &v);
//! Template instantiation of operator/
template bvec operator/(const bin t, const bvec &v);
//------------- Elementwise Division operator ----------
//! Template instantiation of elem_div
template vec elem_div(const vec &v1, const vec &v2);
//! Template instantiation of elem_div
template cvec elem_div(const cvec &v1, const cvec &v2);
//! Template instantiation of elem_div
template ivec elem_div(const ivec &v1, const ivec &v2);
//! Template instantiation of elem_div
template svec elem_div(const svec &v1, const svec &v2);
//! Template instantiation of elem_div
template bvec elem_div(const bvec &v1, const bvec &v2);
//! Template instantiation of elem_div
template vec elem_div(const double t, const vec &v);
//! Template instantiation of elem_div
template cvec elem_div(const complex<double> t, const cvec &v);
//! Template instantiation of elem_div
template ivec elem_div(const int t, const ivec &v);
//! Template instantiation of elem_div
template svec elem_div(const short t, const svec &v);
//! Template instantiation of elem_div
template bvec elem_div(const bin t, const bvec &v);
//--------------------- concat operator -----------------
//! Template instantiation of concat
template vec concat(const vec &v, const double a);
//! Template instantiation of concat
template cvec concat(const cvec &v, const complex<double> a);
//! Template instantiation of concat
template ivec concat(const ivec &v, const int a);
//! Template instantiation of concat
template svec concat(const svec &v, const short a);
//! Template instantiation of concat
template bvec concat(const bvec &v, const bin a);
//! Template instantiation of concat
template vec concat(const double a, const vec &v);
//! Template instantiation of concat
template cvec concat(const complex<double> a, const cvec &v);
//! Template instantiation of concat
template ivec concat(const int a, const ivec &v);
//! Template instantiation of concat
template svec concat(const short a, const svec &v);
//! Template instantiation of concat
template bvec concat(const bin a, const bvec &v);
//! Template instantiation of concat
template vec concat(const vec &v1, const vec &v2);
//! Template instantiation of concat
template cvec concat(const cvec &v1, const cvec &v2);
//! Template instantiation of concat
template ivec concat(const ivec &v1, const ivec &v2);
//! Template instantiation of concat
template svec concat(const svec &v1, const svec &v2);
//! Template instantiation of concat
template bvec concat(const bvec &v1, const bvec &v2);
//! Template instantiation of concat
template vec concat(const vec &v1, const vec &v2, const vec &v3);
//! Template instantiation of concat
template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
//! Template instantiation of concat
template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
//! Template instantiation of concat
template svec concat(const svec &v1, const svec &v2, const svec &v3);
//! Template instantiation of concat
template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
//! Template instantiation of concat
template vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
//! Template instantiation of concat
template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
//! Template instantiation of concat
template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
//! Template instantiation of concat
template svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
//! Template instantiation of concat
template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
//! Template instantiation of concat
template vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4, const vec &v5);
//! Template instantiation of concat
template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4, const cvec &v5);
//! Template instantiation of concat
template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4, const ivec &v5);
//! Template instantiation of concat
template svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4, const svec &v5);
//! Template instantiation of concat
template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4, const bvec &v5);
// -------------- output stream --------------------
//! Template instantiation of output stream
template ostream &operator<<(ostream& os, const vec &vect);
//! Template instantiation of output stream
template ostream &operator<<(ostream& os, const cvec &vect);
//! Template instantiation of output stream
template ostream &operator<<(ostream& os, const svec &vect);
//! Template instantiation of output stream
template ostream &operator<<(ostream& os, const ivec &vect);
//! Template instantiation of output stream
template ostream &operator<<(ostream& os, const bvec &vect);
// -------------- input stream --------------------
//! Template instantiation of input stream
template istream &operator>>(istream& is, vec &vect);
//! Template instantiation of input stream
template istream &operator>>(istream& is, cvec &vect);
//! Template instantiation of input stream
template istream &operator>>(istream& is, svec &vect);
//! Template instantiation of input stream
template istream &operator>>(istream& is, ivec &vect);
//! Template instantiation of input stream
template istream &operator>>(istream& is, bvec &vect);
} //namespace itpp
syntax highlighted by Code2HTML, v. 0.9.1