30 # include <itpp/config.h> 32 # include <itpp/config_msvc.h> 35 #if defined (HAVE_BLAS) 36 # include <itpp/base/blas.h> 49 int Vec<int>::parse_token(
const std::string &s)
const 52 std::istringstream buffer(s);
53 if (s.find(
'x', 1) != std::string::npos) {
54 buffer >> std::hex >> out;
56 else if (((s[0] ==
'0')
57 || (((s[0] ==
'-') || (s[0] ==
'+')) && (s[1] ==
'0')))
58 && (s.find(
'8', 1) == std::string::npos)
59 && (s.find(
'9', 1) == std::string::npos)) {
60 buffer >> std::oct >> out;
63 buffer >> std::dec >> out;
69 double Vec<double>::parse_token(
const std::string &s)
const 72 if ((s ==
"NaN") || (s ==
"nan") || (s ==
"NAN")) {
73 if (std::numeric_limits<double>::has_quiet_NaN)
74 out = std::numeric_limits<double>::quiet_NaN();
75 else if (std::numeric_limits<double>::has_signaling_NaN)
76 out = std::numeric_limits<double>::signaling_NaN();
78 it_error(
"Vec<double>::set(): NaN not supported");
80 else if ((s ==
"-Inf") || (s ==
"-inf") || (s ==
"-INF")) {
81 out = -std::numeric_limits<double>::infinity();
83 else if ((s ==
"Inf") || (s ==
"inf") || (s ==
"INF") ||
84 (s ==
"+Inf") || (s ==
"+inf") || (s ==
"+INF")) {
85 out = std::numeric_limits<double>::infinity();
88 std::istringstream buffer(s);
90 it_assert(!buffer.fail(),
"Vec<double>::set(): Stream operation failed " 98 void Vec<bin>::set(
const std::string &str)
101 std::vector<std::string> tokens = tokenize(str, abc_format);
102 it_assert(!abc_format,
"Vec<bin>::set(): \"a:b:c\" format string not " 103 "supported for binary vectors");
104 set_size(
int(tokens.size()));
105 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i) {
106 std::istringstream buffer(tokens[i]);
108 it_assert(!buffer.fail(),
"Vec<bin>::set(): Stream operation failed " 114 void Vec<short int>::set(
const std::string &str)
122 void Vec<int>::set(
const std::string &str)
125 std::vector<std::string> tokens = tokenize(str, abc_format);
128 set_size(
int(tokens.size()));
129 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i)
130 data[i] = parse_token(tokens[i]);
134 set_size((tokens.size() > 20) ?
int(tokens.size()) : 20);
135 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i) {
137 if (tokens[i].
find(
':', 1) == std::string::npos) {
138 if (++pos > datasize) {
139 set_size(2 * datasize,
true);
141 data[pos-1] = parse_token(tokens[i]);
145 parse_abc_token(tokens[i], a, b, c);
146 if (++pos > datasize) {
147 set_size(2 * datasize,
true);
151 if ((b > 0) && (c >= a)) {
152 while ((data[pos-1] + b) <= c) {
153 if (++pos > datasize) {
154 set_size(2 * datasize,
true);
156 data[pos-1] = data[pos-2] + b;
159 else if ((b < 0) && (c <= a)) {
160 while ((data[pos-1] + b) >= c) {
161 if (++pos > datasize) {
162 set_size(2 * datasize,
true);
164 data[pos-1] = data[pos-2] + b;
167 else if (b == 0 && c == a) {
171 it_error(
"Vec<int>::set(): Improper data string (a:b:c)");
184 std::vector<std::string> tokens = tokenize(str, abc_format);
187 set_size(
int(tokens.size()));
188 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i)
189 data[i] = parse_token(tokens[i]);
193 set_size((tokens.size() > 20) ?
int(tokens.size()) : 20);
194 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i) {
196 if (tokens[i].
find(
':', 1) == std::string::npos) {
197 if (++pos > datasize) {
198 set_size(2 * datasize,
true);
200 data[pos-1] = parse_token(tokens[i]);
204 parse_abc_token(tokens[i], a, b, c);
205 if (++pos > datasize) {
206 set_size(2 * datasize,
true);
211 double eps_margin = std::fabs((c - a) / b) *
eps;
212 if ((b > 0) && (c >= a)) {
213 while ((data[pos-1] + b) <= (c + eps_margin)) {
214 if (++pos > datasize) {
215 set_size(2 * datasize,
true);
217 data[pos-1] = data[pos-2] + b;
220 else if ((b < 0) && (c <= a)) {
221 while ((data[pos-1] + b) >= (c - eps_margin)) {
222 if (++pos > datasize) {
223 set_size(2 * datasize,
true);
225 data[pos-1] = data[pos-2] + b;
228 else if (b == 0 && c == a) {
232 it_error(
"Vec<double>::set(): Improper data string (a:b:c)");
241 void Vec<std::complex<double> >::set(
const std::string &str)
244 std::vector<std::string> tokens = tokenize(str, abc_format);
245 it_assert(!abc_format,
"Vec<bin>::set(): \"a:b:c\" format string not " 246 "supported for binary vectors");
247 set_size(
int(tokens.size()));
248 for (std::vector<std::string>::size_type i = 0; i < tokens.size(); ++i) {
249 std::istringstream buffer(tokens[i]);
251 it_assert(!buffer.fail(),
"Vec<complex>::set(): Stream operation failed " 256 #if defined(HAVE_BLAS) 260 it_assert_debug(v1.length() == v2.length(),
"vec::dot(): Wrong sizes");
261 int incr = 1;
int v1_l = v1.length();
262 return blas::ddot_(&v1_l, v1._data(), &incr, v2._data(), &incr);
268 it_assert_debug(v1.length() == v2.length(),
"vec::dot(): Wrong sizes");
270 for (
int i = 0; i < v1.length(); ++i)
271 r += v1._data()[i] * v2._data()[i];
276 #if defined(HAVE_BLAS) 281 "Vec::outer_product:: Input vector of zero size");
282 int v1_l = v1.length();
int v2_l = v2.length();
287 blas::dger_(&v1_l, &v2_l, &alpha, v1._data(), &incr,
288 v2._data(), &incr, out._data(), &v1_l);
296 "Vec::outer_product:: Input vector of zero size");
297 int v1_l = v1.length();
int v2_l = v2.length();
298 cmat out(v1_l, v2_l);
300 std::complex<double> alpha(1.0);
303 blas::zgerc_(&v1_l, &v2_l, &alpha, v1._data(), &incr,
304 v2._data(), &incr, out._data(), &v1_l);
307 blas::zgeru_(&v1_l, &v2_l, &alpha, v1._data(), &incr,
308 v2._data(), &incr, out._data(), &v1_l);
317 "Vec::outer_product:: Input vector of zero size");
318 int v1_l = v1.length();
int v2_l = v2.length();
320 for (
int i = 0; i < v1_l; ++i) {
321 for (
int j = 0; j < v2_l; ++j) {
322 out(i, j) = v1._data()[i] * v2._data()[j];
332 "Vec::outer_product:: Input vector of zero size");
333 int v1_l = v1.length();
int v2_l = v2.length();
334 cmat out(v1_l, v2_l);
336 for (
int i = 0; i < v1_l; ++i) {
337 for (
int j = 0; j < v2_l; ++j) {
338 out(i, j) = v1._data()[i] *
conj(v2._data()[j]);
343 for (
int i = 0; i < v1_l; ++i) {
344 for (
int j = 0; j < v2_l; ++j) {
345 out(i, j) = v1._data()[i] * v2._data()[j];
355 bvec Vec<std::complex<double> >::operator<=(std::complex<double>)
const 357 it_error(
"operator<=: not implemented for complex");
363 bvec Vec<std::complex<double> >::operator>(std::complex<double>)
const 365 it_error(
"operator>: not implemented for complex");
371 bvec Vec<std::complex<double> >::operator<(std::complex<double>)
const 373 it_error(
"operator<: not implemented for complex");
379 bvec Vec<std::complex<double> >::operator>=(std::complex<double>)
const 381 it_error(
"operator>=: not implemented for complex");
389 Mat<std::complex<double> > temp(1, datasize);
390 for (
int i = 0; i < datasize; i++)
401 template class ITPP_EXPORT Vec<double>;
402 template class ITPP_EXPORT Vec<int>;
403 template class ITPP_EXPORT Vec<short int>;
404 template class ITPP_EXPORT Vec<std::complex<double> >;
405 template class ITPP_EXPORT Vec<bin>;
456 template ITPP_EXPORT std::complex<double>
dot(
const cvec &v1,
const cvec &v2);
457 template ITPP_EXPORT
int dot(
const ivec &v1,
const ivec &v2);
458 template ITPP_EXPORT
short dot(
const svec &v1,
const svec &v2);
459 template ITPP_EXPORT bin
dot(
const bvec &v1,
const bvec &v2);
462 template ITPP_EXPORT std::complex<double>
operator*(
const cvec &v1,
const cvec &v2);
596 template ITPP_EXPORT
vec concat(
const vec &v,
double a);
597 template ITPP_EXPORT
cvec concat(
const cvec &v, std::complex<double> a);
602 template ITPP_EXPORT
vec concat(
double a,
const vec &v);
603 template ITPP_EXPORT
cvec concat(std::complex<double> a,
const cvec &v);
621 const vec &v3,
const vec &v4);
632 const vec &v4,
const vec &v5);
644 template ITPP_EXPORT std::ostream &
operator<<(std::ostream& os,
const vec &vect);
645 template ITPP_EXPORT std::ostream &
operator<<(std::ostream& os,
const cvec &vect);
646 template ITPP_EXPORT std::ostream &
operator<<(std::ostream& os,
const svec &vect);
647 template ITPP_EXPORT std::ostream &
operator<<(std::ostream& os,
const ivec &vect);
648 template ITPP_EXPORT std::ostream &
operator<<(std::ostream& os,
const bvec &vect);
649 template ITPP_EXPORT std::istream &
operator>>(std::istream& is,
vec &vect);
650 template ITPP_EXPORT std::istream &
operator>>(std::istream& is,
cvec &vect);
651 template ITPP_EXPORT std::istream &
operator>>(std::istream& is,
svec &vect);
652 template ITPP_EXPORT std::istream &
operator>>(std::istream& is,
ivec &vect);
653 template ITPP_EXPORT std::istream &
operator>>(std::istream& is,
bvec &vect);
Mat< Num_T > elem_div(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise division of two matrices.
std::ostream & operator<<(std::ostream &os, const Array< T > &a)
Output stream for Array<T>. T must have ostream operator<< defined.
Mat< double > mat
Default Matrix Type.
std::istream & operator>>(std::istream &is, Array< T > &a)
Input stream for Array<T>. T must have istream operator>> defined.
void elem_div_out(const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
Element wise division of two matrices, storing the result in matrix out.
void set(const char *str)
Set the vector equal to the values in the str string.
Vec< std::complex< double > > cvec
Definition of complex<double> vector type.
ivec find(const bvec &invector)
Return a integer vector with indicies where bvec == 1.
Vec< short int > svec
Definition of short vector type.
Mat< Num_T > elem_mult(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise multiplication of two matrices.
cvec conj(const cvec &x)
Conjugate of complex value.
ITPP_EXPORT GF2mat operator*(const GF2mat &X, const GF2mat &Y)
GF(2) matrix multiplication.
vec operator/(const vec &v, const float &s)
Division operator for vec and float.
Num_T elem_div_sum(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise division of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_div(A, B)).
Vec< bin > bvec
Definition of binary vector type.
#define it_assert(t, s)
Abort if t is not true.
vec operator-(const float &s, const vec &v)
Subtraction operator for float and vec.
#define it_assert_debug(t, s)
Abort if t is not true and NDEBUG is not defined.
Mat< short int > smat
short int matrix
Definitions of converters between different vector and matrix types.
const double eps
Constant eps.
svec to_svec(const Vec< T > &v)
Converts a Vec<T> to svec.
Mat< std::complex< double > > cmat
Default Complex Matrix Type.
ITPP_EXPORT GF2mat operator+(const GF2mat &X, const GF2mat &Y)
GF(2) matrix addition.
void elem_mult_out(const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
Element wise multiplication of two matrices, storing the result in matrix out.
void elem_mult_inplace(const Mat< Num_T > &m1, Mat< Num_T > &m2)
In-place element wise multiplication of two matrices. Fast version of B = elem_mult(A, B).
void hermitian_transpose(const Mat< T > &m, Mat< T > &out)
#define it_error(s)
Abort unconditionally.
Mat< int > imat
Integer matrix.
Vec< int > ivec
Definition of integer vector type.
Mat< Num_T > outer_product(const Vec< Num_T > &v1, const Vec< Num_T > &v2, bool hermitian=false)
Outer product of two vectors v1 and v2.
Num_T dot(const Vec< Num_T > &v1, const Vec< Num_T > &v2)
Inner (dot) product of two vectors v1 and v2.
Num_T elem_mult_sum(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise multiplication of two matrices, followed by summation of the resultant elements...
Vec< double > vec
Definition of double vector type.
Mat< bin > bmat
bin matrix
Templated Vector Class Definitions.
const Array< T > concat(const Array< T > &a, const T &e)
Append element e to the end of the Array a.