TBCI Numerical high perf. C++ Library  2.8.0
fs_vector.h
Go to the documentation of this file.
1 
5 /* $Id: fs_vector.h,v 1.21.2.33 2022/11/03 17:28:10 garloff Exp $ */
6 /* written 99/01/29 KG
7  * revised 99/01/29 KG
8  */
9 
10 #ifndef TBCI_FS_VECTOR_H
11 #define TBCI_FS_VECTOR_H
12 
13 #include "tbci/basics.h"
14 #include "tbci/bvector.h"
15 
16 // Avoid -fguiding-decls
17 #if !defined(NO_GD) && !defined(AUTO_DECL)
18 # include "fs_vector_gd.h"
19 #endif
20 
21 NAMESPACE_TBCI
22 
23 #ifndef TBCI_DISABLE_EXCEPT
24 //# include "except.h" is included in basics.h
25 
27 class FSVecErr : public NumErr
28 {
29  public:
30  FSVecErr()
31  : NumErr("Error in FS_Vector library") {}
32  FSVecErr(const char* t, const long i = 0)
33  : NumErr(t, i) {}
34  FSVecErr(const FSVecErr& fe)
35  : NumErr(fe) {}
36  virtual ~FSVecErr() throw() {}
37 } ;
38 #endif
39 
40 #ifdef PRAGMA_I
41 # pragma interface "fs_vector.h"
42 #endif
43 
44 
45 template <unsigned dims, typename T /* = double*/> class FS_Vector;
46 
47 #if 0
48 template <unsigned dims, typename T, unsigned dims2>
49  inline FS_Vector<dims,T> slice (const FS_Vector<dims,T>&, const unsigned, const unsigned);
50 #endif
51 
61 template <unsigned dims, typename T>
62 class FS_Vector : public Vector_Sig<T>
63 {
64  protected:
65  T x[dims];
66 
67  public:
68  typedef T value_type;
69  typedef T element_type;
70  typedef T aligned_value_type TALIGN(MIN_ALIGN);
71 
72  FS_Vector () {}
73  FS_Vector (const T v) { fill(v); }
74  FS_Vector (const FS_Vector <dims, T> & pc) { CSTD__ memcpy (x, pc.x, sizeof(T)*dims); }
75  //FS_Vector (const FS_Vector <dims, T> & pc) : x (pc.x) {}
76  FS_Vector (const BVector<T>& bv);
77 #ifndef NO_POD
78  FS_Vector (const vararg, ...);
79 #endif
80 
81  operator BVector<T> () const;
82 
83  T& operator [] (const unsigned long i);
84  const T& operator [] (const unsigned long i) const;
85  T& operator () (const unsigned long i);
86  const T& operator () (const unsigned long i) const;
87  // Deref. returns the first component
88  T& operator * () { return x[0]; }
89  const T& operator * () const { return x[0]; }
90 
91  // Promotion (only explicit)
92 #ifndef HAVE_PROMOTION_BUG
93 # ifndef HAVE_GCC295_TMPLFRNDCLS_BUG
94  template <unsigned dm, typename U> friend class FS_Vector;
95 # endif
96  template <typename U> explicit FS_Vector (const FS_Vector<dims, U>& fsv)
97  { for (unsigned i = 0; i < dims; ++i) *(this)(i) = fsv(i); }
98 #endif
99 
100  FS_Vector <dims,T>& init_0 ()
101  { if (dims) CSTD__ memset ((void*)x, 0, sizeof(T)*dims); return *this; }
102  FS_Vector <dims,T>& fill (const T&);
103  // no resize !
104  FS_Vector <dims,T>& clear () { return init_0 (); }
105  // no append !
106  inline unsigned long size () const { return dims; }
107 
108  // Assignment
109  FS_Vector<dims,T>& operator = (const T& a) { return fill (a); }
110  FS_Vector<dims,T>& operator = (const FS_Vector<dims,T>& fv);
111  // no alias !
112 
113  // Comparison ...
114  bool operator == (const FS_Vector<dims,T>&) const;
115  bool operator != (const FS_Vector<dims,T>& fv) const { return !(*this == fv);
116 }
117 
118  // arithmetics
119  FS_Vector <dims,T>& operator += (const FS_Vector<dims,T>&);
120  FS_Vector <dims,T>& operator -= (const FS_Vector<dims,T>&);
121  FS_Vector <dims,T>& operator += (const T &);
122  FS_Vector <dims,T>& operator -= (const T &);
123  FS_Vector <dims,T>& operator *= (const T &);
124  FS_Vector <dims,T>& operator /= (const T &);
125 
126  FS_Vector <dims,T> operator + (const FS_Vector<dims,T>&) const;
127  FS_Vector <dims,T> operator - (const FS_Vector<dims,T>&) const;
128  FS_Vector <dims,T> operator + (const T &) const;
129  FS_Vector <dims,T> operator - (const T &) const;
130  FS_Vector <dims,T> operator * (const T &) const;
131  FS_Vector <dims,T> operator / (const T &) const;
132 
133  FS_Vector <dims,T> operator - () const;
134 
135  FS_Vector <dims,T> incr (const unsigned long, const T = (T)1) const;
136 
137  // for friend NOINST FS_Vector <dims,T> operator * FGD (const T&, const FS_Vector<dims,T>&);
138  FS_Vector<dims,T> mult (const T&) const;
139  //for friend NOINST FS_Vector <dims,T> operator + FGD (const T&, const FS_Vector<dims,T>&);
140  FS_Vector<dims,T> plus (const T&) const;
141  //for friend NOINST FS_Vector <dims,T> operator - FGD (const T&, const FS_Vector<dims,T>&);
142  FS_Vector<dims,T> minus (const T&) const;
143  //friend NOINST FS_Vector <dims,T> operator / FGD (const T&, const FS_Vector<dims,T>&);
144 
145  // IO
146  friend STD__ ostream& operator << FGD (STD__ ostream&, const FS_Vector<dims,T>&);
147  friend STD__ istream& operator >> FGD (STD__ istream&, FS_Vector<dims,T>&);
148 
149  bool contains (const T&, unsigned long* = 0) const;
150 
151  T min () const;
152  T max () const;
153  T sum () const;
154  double fabssqr () const;
155  double fabs () const;
156  T abs () const;
157 
158 #if 1
159  // Comparison ... part two
160  bool operator <= (const FS_Vector<dims,T>& fv) const
161  { return fabssqr() <= fv.fabssqr(); }
162  bool operator >= (const FS_Vector<dims,T>& fv) const
163  { return fabssqr() >= fv.fabssqr(); }
164  bool operator < (const FS_Vector<dims,T>& fv) const
165  { return !((*this) >= fv); }
166  bool operator > (const FS_Vector<dims,T>& fv) const
167  { return !((*this) <= fv); }
168 #endif
169 
170 #if 0
171  friend NOINST T min FGD (const FS_Vector<dims,T>&);
172  friend NOINST T max FGD (const FS_Vector<dims,T>&);
173  friend NOINST T sum FGD (const FS_Vector<dims,T>&);
174  //template <unsigned dims, typename T>
175  friend NOINST double MATH__ fabs FGD (const FS_Vector<dims,T>&);
176  //template <unsigned dims, typename T>
177  friend NOINST T CSTD__ abs FGD (const FS_Vector<dims,T>&);
178  //template <unsigned dims, typename T>
179  friend NOINST double fabssqr FGD (const FS_Vector<dims,T>&);
180 #endif
181 
182  friend T dot FGD (const FS_Vector<dims,T>&, const FS_Vector<dims,T>&);
183 
184 #if 0
185  template <unsigned dims, typename T, unsigned d2>
186  friend FS_Vector<d2,T> slice /*<dims,T,d2>*/ (const FS_Vector<dims,T>&, const unsigned, const unsigned = dims);
187 #endif
188 
189  // access to data pointer for e.g. fortran libs
190  T* vecptr () const { return (T*)x; }
191  T* get_fortran_vector () const { return vecptr (); }
192  // You'd better know, what you are doing!
193  //void set_fortran_vector (T* pointer) { x = pointer; }
194 } ;
195 
196 template <unsigned dims, typename T>
197 inline FS_Vector<dims,T>::FS_Vector (const BVector<T> & bv)
198 {
199  BCHKNR (bv.size() != dims, FSVecErr, Wrong dim in FS_Vector BVector constructor, bv.size());
200  CSTD__ memcpy (x, bv.vecptr(), sizeof(T)*dims);
201 }
202 
203 #ifndef NO_POD
204 template <unsigned dims, typename T>
205 inline FS_Vector<dims,T>::FS_Vector (const vararg va, ...)
206 {
207  BCHKNR ((unsigned)va != dims, FSVecErr, No. of vararg params unequals dimension, va);
208  clear ();
209  va_list vl; va_start (vl, va);
210 #if !defined(__clang__) || !defined(CPLX)
211  for (unsigned long i = 0; i < MIN ((unsigned)va,dims); ++i)
212  x[i] = va_arg (vl, T);
213 #else
214  throw FSVecErr("vararg not supported for cplx in clang");
215 #warning no vararg support with cplx numbers and clang
216 #endif
217  va_end (vl);
218 }
219 #endif
220 
221 template <unsigned dims, typename T>
222 inline FS_Vector<dims,T>::operator BVector<T> () const
223 {
224  BVector<T> bv (dims);
225  CSTD__ memcpy (&bv(0), x, sizeof(T) * dims);
226  return bv;
227 }
228 
229 template <unsigned dims, typename T>
230 inline const T& FS_Vector<dims,T>::operator [] (const unsigned long i) const
231 {
232  BCHK (i >= dims, FSVecErr, FS_Vector idx out of range, i, x[0]);
233  return x[i];
234 }
235 template <unsigned dims, typename T>
236 inline T& FS_Vector<dims,T>::operator [] (const unsigned long i)
237 {
238  BCHK (i >= dims, FSVecErr, FS_Vector idx out of range, i, x[0]);
239  return x[i];
240 }
241 template <unsigned dims, typename T>
242 inline const T& FS_Vector<dims,T>::operator () (const unsigned long i) const
243 {
244  BCHK (i >= dims, FSVecErr, FS_Vector idx out of range, i, x[0]);
245  return x[i];
246 }
247 template <unsigned dims, typename T>
248 inline T& FS_Vector<dims,T>::operator () (const unsigned long i)
249 {
250  BCHK (i >= dims, FSVecErr, FS_Vector idx out of range, i, x[0]);
251  return x[i];
252 }
253 
254 template <unsigned dims, typename T>
255 inline FS_Vector<dims,T>& FS_Vector<dims,T>::fill (const T& v)
256 {
257  for (unsigned long i = 0; i < dims; ++i)
258  x[i] = v;
259  return *this;
260 }
261 
262 template <unsigned dims, typename T>
263 inline FS_Vector<dims,T>& FS_Vector<dims,T>::operator = (const FS_Vector <dims,T>& fv)
264 {
265  CSTD__ memcpy (x, fv.x, sizeof(T)*dims);
266  return *this;
267 }
268 
269 template <unsigned dims, typename T>
270 inline bool FS_Vector<dims,T>::operator == (const FS_Vector <dims,T>& fv) const
271 {
272  return !(CSTD__ memcmp (x, fv.x, sizeof(T)*dims));
273 }
274 
275 #if 0
276 template <unsigned dims, typename T>
277 inline bool FS_Vector<dims,T>::operator <= (const FS_Vector <dims,T>& fv) const
278 {
279  return (fabsqr() <= fv.fabssqr());
280 }
281 
282 template <unsigned dims, typename T>
283 inline bool FS_Vector<dims,T>::operator >= (const FS_Vector <dims,T>& fv) const
284 {
285  return (fabsqr() >= fv.fabssqr());
286 }
287 #endif
288 
289 #define FSV_ASS_FSV(op) \
290 template <unsigned dims, typename T> \
291 inline FS_Vector<dims,T>& FS_Vector<dims,T>::operator op (const FS_Vector <dims,T>& fv) \
292 { \
293  for (unsigned long i = 0; i < dims; ++i) \
294  x[i] op fv[i]; \
295  return *this; \
296 }
297 
298 FSV_ASS_FSV (+=)
299 FSV_ASS_FSV (-=)
300 
301 #define FSV_NOASS_FSV(op) \
302 template <unsigned dims, typename T> \
303 inline FS_Vector<dims,T> FS_Vector<dims,T>::operator op (const FS_Vector <dims,T>& fv) const \
304 { \
305  FS_Vector <dims,T> rv; \
306  for (unsigned long i = 0; i < dims; ++i) \
307  rv[i] = x[i] op fv[i]; \
308  return rv; \
309 }
310 
311 FSV_NOASS_FSV (+)
312 FSV_NOASS_FSV (-)
313 
314 #define FSV_ASS_T(op) \
315 template <unsigned dims, typename T> \
316 inline FS_Vector<dims,T>& FS_Vector<dims,T>::operator op (const T& v) \
317 { \
318  for (unsigned long i = 0; i < dims; ++i) \
319  x[i] op v; \
320  return *this; \
321 }
322 
323 FSV_ASS_T (+=)
324 FSV_ASS_T (-=)
325 FSV_ASS_T (*=)
326 //FSV_ASS_T (/=)
327 
328 #define FSV_NOASS_T(op) \
329 template <unsigned dims, typename T> \
330 inline FS_Vector<dims,T> FS_Vector<dims,T>::operator op (const T& v) const \
331 { \
332  FS_Vector<dims,T> rv; \
333  for (unsigned long i = 0; i < dims; ++i) \
334  rv[i] = x[i] op v; \
335  return rv; \
336 }
337 
338 FSV_NOASS_T (+)
339 FSV_NOASS_T (-)
340 FSV_NOASS_T (*)
341 //FSV_NOASS_T (/)
342 
343 template <unsigned dims, typename T>
344 inline FS_Vector<dims,T>& FS_Vector<dims,T>::operator /= (const T& v)
345 {
346  BCHK (v == (T)0, FSVecErr, Division by zero, 0, *this);
347  for (unsigned long i = 0; i < dims; ++i)
348  x[i] /= v;
349  return *this;
350 }
351 
352 
353 template <unsigned dims, typename T>
354 inline FS_Vector<dims,T> FS_Vector<dims,T>::operator / (const T& v) const
355 {
356  FS_Vector<dims,T> rv;
357  BCHK (v == (T)0, FSVecErr, Division by zero, 0, rv);
358  for (unsigned long i = 0; i < dims; ++i)
359  rv[i] = x[i] / v;
360  return rv;
361 }
362 
363 
364 template <unsigned dims, typename T>
365 inline FS_Vector <dims,T> FS_Vector <dims,T>::operator - () const
366 {
367  FS_Vector<dims,T> rv;
368  for (unsigned long i = 0; i < dims; ++i)
369  rv[i] = -x[i];
370  return rv;
371 }
372 
373 
374 template <unsigned dims, typename T>
375 inline FS_Vector <dims,T> FS_Vector <dims,T>::incr (const unsigned long wh, const T i) const
376 {
377  FS_Vector fv (*this);
378  BCHK (wh >= dims, FSVecErr, Tried to change not-exitsting idx, wh, fv);
379  fv.x[wh] += i;
380  return fv;
381 }
382 
383 
384 template <unsigned dims, typename T>
385 STD__ ostream& operator << (STD__ ostream& os, const FS_Vector<dims,T>& fv)
386 {
387  if (!dims) return os;
388  os << fv.x[0];
389  for (unsigned long i = 1; i < dims; ++i)
390  os << ", " << fv.x[i];
391  return os;
392 }
393 
394 #ifndef PTR
395 template <unsigned dims, typename T>
396 STD__ istream& operator >> (STD__ istream& in, FS_Vector<dims,T>& v)
397 {
398  T r ALIGN(MIN_ALIGN) = 0;
399  char s = ',';
400 
401  if( !( in >> s ) )
402  return in;
403  if (s != '(') in.putback(s);
404  if( !( in >> r ) )
405  return in;
406  v[0] = r;
407  for (unsigned long i = 1; i < dims; ++i) {
408  in >> s;
409  if (s != ',') in.putback(s);
410  if( !( in >> r ) )
411  return in;
412  v[i] = r;
413  }
414  return in;
415 }
416 #else
417 template <unsigned dims, typename T>
418 STD__ istream& operator >> (STD__ istream& in, FS_Vector<dims,T>& v)
419 {
420  STD__ cerr << "fs_vector: Input on pointer types not possible!" << STD__ endl;
421  abort ();
422  return in;
423 }
424 #endif
425 
426 
427 template <unsigned dims, typename T>
428 inline bool FS_Vector<dims,T>::contains (const T& val, unsigned long *ind) const
429 {
430  for (REGISTER unsigned long i = 0; i < dims; ++i)
431  if (val == x[i]) {
432  if (ind) *ind = i;
433  return true;
434  }
435  return false;
436 }
437 
438 template <unsigned dims, typename T>
439 INLINE T FS_Vector<dims,T>::min () const
440 {
441  if (dims == 0) return 0;
442  T min ALIGN(MIN_ALIGN) = x[0];
443  for (REGISTER unsigned long t = 1; t < dims; ++t)
444  if (x[t] < min)
445  min = x[t];
446  return min;
447 }
448 
449 template <unsigned dims, typename T>
450 INLINE T FS_Vector<dims,T>::max () const
451 {
452  if (dims == 0) return 0;
453  T max ALIGN(MIN_ALIGN) = x[0];
454  for (REGISTER unsigned long t = 1; t < dims; ++t)
455  if (x[t] > max)
456  max = x[t];
457  return max;
458 }
459 
460 template <unsigned dims, typename T>
461 INLINE T FS_Vector<dims,T>::sum () const
462 {
463  T sum ALIGN(MIN_ALIGN) = 0;
464  for (REGISTER unsigned long t = 0; t < dims; ++t)
465  sum += x[t];
466  return sum;
467 }
468 
469 
470 template <unsigned dims, typename T>
471 inline T dot (const FS_Vector<dims,T>& fv1, const FS_Vector<dims,T>& fv2)
472 {
473  if (dims == 0) return 0;
474  ALIGN3(T s, CPLX__ conj (fv1[0]) * fv2[0] ,MIN_ALIGN2);
475  for (REGISTER unsigned long i = 1; i < dims; ++i)
476  s += CPLX__ conj (fv1[i]) * fv2[i];
477  return s;
478 }
479 
480 template <unsigned dims, typename T>
481 inline double FS_Vector<dims,T>::fabssqr () const
482 {
483  return CPLX__ real(dot (*this, *this));
484 }
485 
486 template <unsigned dims, typename T>
487 inline double FS_Vector<dims,T>::fabs () const
488 {
489  return MATH__ sqrt (fabssqr());
490 }
491 
492 template <unsigned dims, typename T>
493 INLINE T FS_Vector<dims,T>::abs () const
494 {
495  return (T) MATH__ sqrt (fabssqr());
496 }
497 
498 //INST5(template <unsigned dims, typename T, unsigned long dims2> class FS_Vector<dims,T> friend FS_Vector<dims,T> slice (const FS_Vector<dims,T>&, const unsigned long, const unsigned long);)
499 template <unsigned dims, typename T, unsigned long dims2>
500 inline FS_Vector<dims,T> slice (const FS_Vector<dims,T>& fv, const unsigned long s, const unsigned long e)
501 {
502  FS_Vector<dims2,T> rv; rv.clear();
503  BCHK (dims2 != e-s, FSVecErr, slice template param is wrong, dims2, rv);
504  CSTD__ memcpy (rv.x, fv.vecptr()+s, sizeof(T) * (MIN((unsigned)e,dims)-s));
505  return rv;
506 }
507 
508 
509 template <unsigned dims, typename T>
510 FS_Vector<dims,T> emul (const FS_Vector<dims,T>& f1, const FS_Vector<dims,T>& f2)
511 {
512  FS_Vector<dims,T> res;
513  for (unsigned long i = 0; i < dims; ++i)
514  res(i) = f1(i) * f2(i);
515  return res;
516 }
517 
518 template <unsigned dims, typename T>
519 FS_Vector<dims,T> cemul (const FS_Vector<dims,T>& f1, const FS_Vector<dims,T>& f2)
520 {
521  FS_Vector<dims,T> res;
522  for (unsigned long i = 0; i < dims; ++i)
523  res(i) = CPLX__ conj(f1(i)) * f2(i);
524  return res;
525 }
526 
527 template <unsigned dims, typename T>
528 FS_Vector<dims,T> ediv (const FS_Vector<dims,T>& f1, const FS_Vector<dims,T>& f2)
529 {
530  FS_Vector<dims,T> res;
531  for (unsigned long i = 0; i < dims; ++i)
532  res(i) = f1(i) / f2(i);
533  return res;
534 }
535 
536 template <unsigned dims, typename T>
537 FS_Vector<dims,T> cediv (const FS_Vector<dims,T>& f1, const FS_Vector<dims,T>& f2)
538 {
539  FS_Vector<dims,T> res;
540  for (unsigned long i = 0; i < dims; ++i)
541  res(i) = CPLX__ conj(f1(i)) / f2(i);
542  return res;
543 }
544 
545 
546 INST2(template <unsigned dims, typename T> class FS_Vector friend double fabssqr (const FS_Vector<dims,T>&);)
547 template <unsigned dims, typename T>
548 inline double fabssqr (const FS_Vector<dims,T>& fv)
549 { return fv.fabssqr(); }
550 
551 
552 #define FSV_MEM_FRD(nm,op) \
553 template <unsigned dims, typename T> \
554 INLINE FS_Vector<dims,T> FS_Vector<dims,T>:: nm (const T& v) const \
555 { \
556  FS_Vector<dims,T> res; \
557  for (unsigned long i = 0; i < dims; ++i) \
558  res.x[i] = v op x[i]; \
559  return res; \
560 }
561 
562 FSV_MEM_FRD(mult,*)
563 FSV_MEM_FRD(plus,*)
564 FSV_MEM_FRD(minus,*)
565 
566 
567 INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator * (const T&, const FS_Vector<dims,T>&);)
568 template <unsigned dims, typename T>
569 inline FS_Vector<dims,T> operator * (const T& v, const FS_Vector<dims,T>& fv)
570 { return fv.mult (v); }
571 
572 INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator + (const T&, const FS_Vector<dims,T>&);)
573 template <unsigned dims, typename T>
574 inline FS_Vector<dims,T> operator + (const T& v, const FS_Vector<dims,T>& fv)
575 { return fv.plus(v); }
576 
577 INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator - (const T&, const FS_Vector<dims,T>&);)
578 template <unsigned dims, typename T>
579 inline FS_Vector<dims,T> operator - (const T& v, const FS_Vector<dims,T>& fv)
580 { return fv.minus(v); }
581 
582 //INST(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator / (const T&, const FS_Vector<dims,T>&);)
583 //template <unsigned dims, typename T>
584 //inline FS_Vector <dims,T> operator / (const T& v, const FS_Vector<dims,T>& fv)
585 // { return fv.operator / (v); }
586 
587 INST2(template <unsigned dims, typename T> class FS_Vector friend T min (const FS_Vector<dims,T>&);)
588 template <unsigned dims, typename T>
589 inline T min (const FS_Vector<dims,T>& fv)
590 { return fv.min(); }
591 
592 INST2(template <unsigned dims, typename T> class FS_Vector friend T max (const FS_Vector<dims,T>&);)
593 template <unsigned dims, typename T>
594 inline T max (const FS_Vector<dims,T>& fv)
595 { return fv.max(); }
596 
597 INST2(template <unsigned dims, typename T> class FS_Vector friend T sum (const FS_Vector<dims,T>&);)
598 template <unsigned dims, typename T>
599 inline T sum (const FS_Vector<dims,T>& fv)
600 { return fv.sum(); }
601 
602 NAMESPACE_END
603 
604 NAMESPACE_CSTD
605 
606 INST2(template <unsigned dims, typename T> class TBCI__ FS_Vector friend double fabs (const TBCI__ FS_Vector<dims,T>&);)
607 template <unsigned dims, typename T>
608 inline double fabs (const TBCI__ FS_Vector<dims,T>& fv)
609 { return fv.fabs(); }
610 
611 #if (_MSC_VER) && (_MSC_VER == 1200)
612 // the instantiation below causes an ICE on MSVC 6.
613 #else
614 INST2(template <unsigned dims, typename T> class TBCI__ FS_Vector friend T abs (const TBCI__ FS_Vector<dims,T>&);)
615 template <unsigned dims, typename T>
616 inline T abs (const TBCI__ FS_Vector<dims,T>& fv)
617 { return fv.abs(); }
618 #endif
619 NAMESPACE_CSTD_END
620 
621 #endif /* TBCI_FS_VECTOR_H */
sum
T sum(const FS_Vector< dims, T > &fv)
Definition: fs_vector.h:599
BCHKNR
#define BCHKNR(cond, exc, txt, ind)
Definition: basics.h:586
x
const Vector< T > const Vector< T > & x
Definition: LM_fit.h:97
Vector_Sig
abstract base class (signature) for Vectors with arithmetics
Definition: vector_sig.h:24
FS_Vector::FGD
friend T dot FGD(const FS_Vector< dims, T > &, const FS_Vector< dims, T > &)
MIN_ALIGN
#define MIN_ALIGN
Definition: basics.h:421
ALIGN
#define ALIGN(x)
Definition: basics.h:444
FSV_ASS_T
#define FSV_ASS_T(op)
Definition: fs_vector.h:314
FS_Vector::clear
FS_Vector< dims, T > & clear()
Definition: fs_vector.h:104
FS_Vector::operator>=
bool operator>=(const FS_Vector< dims, T > &fv) const
Definition: fs_vector.h:162
BVector
provides basic Vector functionality but arithmetic operators (+=, - , *, /...).
Definition: bvector.h:67
FS_Vector::value_type
T value_type
Definition: fs_vector.h:68
operator>>
STD__ istream & operator>>(STD__ istream &istr, BdMatrix< T > &mat)
Definition: band_matrix.h:2739
FS_Vector::operator/=
FS_Vector< dims, T > & operator/=(const T &)
Definition: fs_vector.h:344
FSV_NOASS_FSV
#define FSV_NOASS_FSV(op)
Definition: fs_vector.h:301
FS_Vector::operator+=
FS_Vector< dims, T > & operator+=(const FS_Vector< dims, T > &)
Definition: fs_vector.h:298
REGISTER
#define REGISTER
Definition: basics.h:108
std::fabs
double fabs(const int a)
Definition: basics.h:1215
MIN
#define MIN(a, b)
Definition: basics.h:655
FS_Vector::operator()
T & operator()(const unsigned long i)
Definition: fs_vector.h:248
NAMESPACE_TBCI
#define NAMESPACE_TBCI
Definition: basics.h:317
FSVecErr
exception class
Definition: fs_vector.h:27
BVector::size
unsigned long size() const HOT
Definition: bvector.h:144
NumErr
exception base class for the TBCI NumLib
Definition: except.h:58
FS_Vector::FS_Vector
FS_Vector()
Definition: fs_vector.h:72
FS_Vector::FS_Vector
FS_Vector(const T v)
Definition: fs_vector.h:73
MIN_ALIGN2
#define MIN_ALIGN2
Definition: basics.h:424
slice
FS_Vector< dims, T > slice(const FS_Vector< dims, T > &fv, const unsigned long s, const unsigned long e)
Definition: fs_vector.h:500
BVector::vecptr
T *const & vecptr() const
Definition: bvector.h:147
cediv
FS_Vector< dims, T > cediv(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition: fs_vector.h:537
BCHK
#define BCHK(cond, exc, txt, ind, rtval)
Definition: basics.h:575
NAMESPACE_CSTD_END
#define NAMESPACE_CSTD_END
Definition: basics.h:325
max
T max(const FS_Vector< dims, T > &fv)
Definition: fs_vector.h:594
FS_Vector::TALIGN
T aligned_value_type TALIGN(MIN_ALIGN)
Definition: fs_vector.h:70
FSV_MEM_FRD
#define FSV_MEM_FRD(nm, op)
Definition: fs_vector.h:552
FS_Vector::operator/
FS_Vector< dims, T > operator/(const T &) const
Definition: fs_vector.h:354
FS_Vector::operator>
bool operator>(const FS_Vector< dims, T > &fv) const
Definition: fs_vector.h:166
std::sqrt
double sqrt(const int a)
Definition: basics.h:1216
FS_Vector::operator*=
FS_Vector< dims, T > & operator*=(const T &)
Definition: fs_vector.h:325
FSV_NOASS_T
#define FSV_NOASS_T(op)
Definition: fs_vector.h:328
CSTD__
#define CSTD__
Definition: basics.h:340
FS_Vector::max
T max() const
Definition: fs_vector.h:450
FSVecErr::FSVecErr
FSVecErr(const FSVecErr &fe)
Definition: fs_vector.h:34
FS_Vector::min
T min() const
Definition: fs_vector.h:439
FS_Vector::operator*
T & operator*()
Definition: fs_vector.h:88
FS_Vector::operator-
FS_Vector< dims, T > operator-() const
Definition: fs_vector.h:365
TBCI__
#define TBCI__
Definition: basics.h:332
FS_Vector::minus
FS_Vector< dims, T > minus(const T &) const
Definition: fs_vector.h:564
ediv
FS_Vector< dims, T > ediv(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition: fs_vector.h:528
FSVecErr::FSVecErr
FSVecErr(const char *t, const long i=0)
Definition: fs_vector.h:32
FS_Vector::operator-=
FS_Vector< dims, T > & operator-=(const FS_Vector< dims, T > &)
Definition: fs_vector.h:299
FS_Vector::incr
FS_Vector< dims, T > incr(const unsigned long, const T=(T) 1) const
Definition: fs_vector.h:375
INST2
#define INST2(x, y)
Definition: basics.h:239
std::conj
int conj(const int arg)
conj for elementary types
Definition: basics.h:1055
NAMESPACE_CSTD
#define NAMESPACE_CSTD
Definition: basics.h:319
param
const Vector< T > Vector< T > & param
Definition: LM_fit.h:172
FS_Vector::sum
T sum() const
Definition: fs_vector.h:461
FS_Vector::operator!=
bool operator!=(const FS_Vector< dims, T > &fv) const
Definition: fs_vector.h:115
FS_Vector::fabs
double fabs() const
Definition: fs_vector.h:487
FSVecErr::FSVecErr
FSVecErr()
Definition: fs_vector.h:30
INST3
#define INST3(x, y, z)
Definition: basics.h:240
FS_Vector::init_0
FS_Vector< dims, T > & init_0()
Definition: fs_vector.h:100
dims
#define dims
Definition: fsveclib.cc:45
FSVecErr::~FSVecErr
virtual ~FSVecErr()
Definition: fs_vector.h:36
CPLX__
#define CPLX__
Definition: basics.h:341
FS_Vector::operator+
FS_Vector< dims, T > operator+(const FS_Vector< dims, T > &) const
Definition: fs_vector.h:311
TBCI::dot
T dot(const T &a1, const T &a2)
Definition: basics.h:1183
FS_Vector::operator<=
bool operator<=(const FS_Vector< dims, T > &fv) const
Definition: fs_vector.h:160
i
int i
Definition: LM_fit.h:71
FS_Vector::abs
T abs() const
Definition: fs_vector.h:493
real
#define real
Definition: own_lapack_routines.cpp:20
FS_Vector::FS_Vector
FS_Vector(const FS_Vector< dims, T > &pc)
Definition: fs_vector.h:74
FS_Vector::mult
FS_Vector< dims, T > mult(const T &) const
Definition: fs_vector.h:562
FS_Vector::operator=
FS_Vector< dims, T > & operator=(const T &a)
Definition: fs_vector.h:109
FS_Vector::fabssqr
double fabssqr() const
Definition: fs_vector.h:481
STD__
#define STD__
Definition: basics.h:338
FS_Vector::operator==
bool operator==(const FS_Vector< dims, T > &) const
Definition: fs_vector.h:270
FS_Vector::x
T x[dims]
Definition: fs_vector.h:65
FS_Vector::fill
FS_Vector< dims, T > & fill(const T &)
Definition: fs_vector.h:255
abs
#define abs(x)
Definition: f2c.h:178
INLINE
#define INLINE
Definition: basics.h:688
NAMESPACE_END
#define NAMESPACE_END
Definition: basics.h:323
FS_Vector
Implementation of fixed sized Vectors (template argument) which is favorable for small Vectors...
Definition: fs_vector.h:45
res
const Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > long int res
Definition: LM_fit.h:199
ALIGN3
#define ALIGN3(v, i, x)
Definition: basics.h:442
TBCI::fabssqr
double fabssqr(const double a)
Definition: basics.h:1157
cemul
FS_Vector< dims, T > cemul(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition: fs_vector.h:519
T
#define T
Definition: bdmatlib.cc:20
FS_Vector::contains
bool contains(const T &, unsigned long *=0) const
Definition: fs_vector.h:428
FS_Vector::element_type
T element_type
Definition: fs_vector.h:69
FS_Vector::vecptr
T * vecptr() const
Definition: fs_vector.h:190
FS_Vector::plus
FS_Vector< dims, T > plus(const T &) const
Definition: fs_vector.h:563
FS_Vector::operator[]
T & operator[](const unsigned long i)
Definition: fs_vector.h:236
FSV_ASS_FSV
#define FSV_ASS_FSV(op)
Definition: fs_vector.h:289
FS_Vector::get_fortran_vector
T * get_fortran_vector() const
Definition: fs_vector.h:191
a
const unsigned TMatrix< T > const Matrix< T > * a
Definition: matrix_kernels.h:25
FS_Vector::size
unsigned long size() const
Definition: fs_vector.h:106
v
const Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > Vector< T > long int int char v
&lt; find minimun of func on grid with resolution res
Definition: LM_fit.h:205
min
#define min(a, b)
Definition: f2c.h:180
MATH__
#define MATH__
Definition: basics.h:339
TBCI::vararg
enum _vararg vararg
Definition: basics.h:1276
FS_Vector::FS_Vector
FS_Vector(const FS_Vector< dims, U > &fsv)
Definition: fs_vector.h:96
emul
FS_Vector< dims, T > emul(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition: fs_vector.h:510
Generated by   doxygen 1.8.5