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
21NAMESPACE_TBCI
22
23#ifndef TBCI_DISABLE_EXCEPT
24//# include "except.h" is included in basics.h
25
27class 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
45template <unsigned dims, typename T /* = double*/> class FS_Vector;
46
47#if 0
48template <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
61template <unsigned dims, typename T>
62class 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
196template <unsigned dims, typename T>
197inline 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
204template <unsigned dims, typename T>
205inline 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
221template <unsigned dims, typename T>
222inline 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
229template <unsigned dims, typename T>
230inline 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}
235template <unsigned dims, typename T>
236inline 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}
241template <unsigned dims, typename T>
242inline 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}
247template <unsigned dims, typename T>
248inline 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
254template <unsigned dims, typename T>
255inline 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
262template <unsigned dims, typename T>
263inline 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
269template <unsigned dims, typename T>
270inline 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
276template <unsigned dims, typename T>
277inline bool FS_Vector<dims,T>::operator <= (const FS_Vector <dims,T>& fv) const
278{
279 return (fabsqr() <= fv.fabssqr());
280}
281
282template <unsigned dims, typename T>
283inline 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) \
290template <unsigned dims, typename T> \
291inline 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
298FSV_ASS_FSV (+=)
299FSV_ASS_FSV (-=)
300
301#define FSV_NOASS_FSV(op) \
302template <unsigned dims, typename T> \
303inline 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
311FSV_NOASS_FSV (+)
312FSV_NOASS_FSV (-)
313
314#define FSV_ASS_T(op) \
315template <unsigned dims, typename T> \
316inline 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
323FSV_ASS_T (+=)
324FSV_ASS_T (-=)
325FSV_ASS_T (*=)
326//FSV_ASS_T (/=)
327
328#define FSV_NOASS_T(op) \
329template <unsigned dims, typename T> \
330inline 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
338FSV_NOASS_T (+)
339FSV_NOASS_T (-)
340FSV_NOASS_T (*)
341//FSV_NOASS_T (/)
342
343template <unsigned dims, typename T>
344inline 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
353template <unsigned dims, typename T>
354inline 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
364template <unsigned dims, typename T>
365inline 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
374template <unsigned dims, typename T>
375inline 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
384template <unsigned dims, typename T>
385STD__ 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
395template <unsigned dims, typename T>
396STD__ 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
417template <unsigned dims, typename T>
418STD__ 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
427template <unsigned dims, typename T>
428inline 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
438template <unsigned dims, typename T>
439INLINE 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
449template <unsigned dims, typename T>
450INLINE 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
460template <unsigned dims, typename T>
461INLINE 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
470template <unsigned dims, typename T>
471inline 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
480template <unsigned dims, typename T>
481inline double FS_Vector<dims,T>::fabssqr () const
482{
483 return CPLX__ real(dot (*this, *this));
484}
485
486template <unsigned dims, typename T>
487inline double FS_Vector<dims,T>::fabs () const
488{
489 return MATH__ sqrt (fabssqr());
490}
491
492template <unsigned dims, typename T>
493INLINE 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);)
499template <unsigned dims, typename T, unsigned long dims2>
500inline 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
509template <unsigned dims, typename T>
510FS_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
518template <unsigned dims, typename T>
519FS_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
527template <unsigned dims, typename T>
528FS_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
536template <unsigned dims, typename T>
537FS_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
546INST2(template <unsigned dims, typename T> class FS_Vector friend double fabssqr (const FS_Vector<dims,T>&);)
547template <unsigned dims, typename T>
548inline double fabssqr (const FS_Vector<dims,T>& fv)
549{ return fv.fabssqr(); }
550
551
552#define FSV_MEM_FRD(nm,op) \
553template <unsigned dims, typename T> \
554INLINE 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
562FSV_MEM_FRD(mult,*)
563FSV_MEM_FRD(plus,*)
564FSV_MEM_FRD(minus,*)
565
566
567INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator * (const T&, const FS_Vector<dims,T>&);)
568template <unsigned dims, typename T>
569inline FS_Vector<dims,T> operator * (const T& v, const FS_Vector<dims,T>& fv)
570{ return fv.mult (v); }
571
572INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator + (const T&, const FS_Vector<dims,T>&);)
573template <unsigned dims, typename T>
574inline FS_Vector<dims,T> operator + (const T& v, const FS_Vector<dims,T>& fv)
575{ return fv.plus(v); }
576
577INST3(template <unsigned dims, typename T> class FS_Vector friend FS_Vector<dims,T> operator - (const T&, const FS_Vector<dims,T>&);)
578template <unsigned dims, typename T>
579inline 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
587INST2(template <unsigned dims, typename T> class FS_Vector friend T min (const FS_Vector<dims,T>&);)
588template <unsigned dims, typename T>
589inline T min (const FS_Vector<dims,T>& fv)
590{ return fv.min(); }
591
592INST2(template <unsigned dims, typename T> class FS_Vector friend T max (const FS_Vector<dims,T>&);)
593template <unsigned dims, typename T>
594inline T max (const FS_Vector<dims,T>& fv)
595{ return fv.max(); }
596
597INST2(template <unsigned dims, typename T> class FS_Vector friend T sum (const FS_Vector<dims,T>&);)
598template <unsigned dims, typename T>
599inline T sum (const FS_Vector<dims,T>& fv)
600{ return fv.sum(); }
601
602NAMESPACE_END
603
604NAMESPACE_CSTD
605
606INST2(template <unsigned dims, typename T> class TBCI__ FS_Vector friend double fabs (const TBCI__ FS_Vector<dims,T>&);)
607template <unsigned dims, typename T>
608inline 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
614INST2(template <unsigned dims, typename T> class TBCI__ FS_Vector friend T abs (const TBCI__ FS_Vector<dims,T>&);)
615template <unsigned dims, typename T>
616inline T abs (const TBCI__ FS_Vector<dims,T>& fv)
617{ return fv.abs(); }
618#endif
619NAMESPACE_CSTD_END
620
621#endif /* TBCI_FS_VECTOR_H */
i
int i
Definition LM_fit.h:71
CSTD__
#define CSTD__
Definition basics.h:340
STD__
#define STD__
Definition basics.h:338
BCHK
#define BCHK(cond, exc, txt, ind, rtval)
Definition basics.h:575
INLINE
#define INLINE
Definition basics.h:688
INST3
#define INST3(x, y, z)
Definition basics.h:240
NAMESPACE_CSTD
#define NAMESPACE_CSTD
Definition basics.h:319
MIN
#define MIN(a, b)
Definition basics.h:655
MIN_ALIGN2
#define MIN_ALIGN2
Definition basics.h:424
ALIGN3
#define ALIGN3(v, i, x)
Definition basics.h:442
NAMESPACE_END
#define NAMESPACE_END
Definition basics.h:323
NAMESPACE_CSTD_END
#define NAMESPACE_CSTD_END
Definition basics.h:325
NAMESPACE_TBCI
#define NAMESPACE_TBCI
Definition basics.h:317
BCHKNR
#define BCHKNR(cond, exc, txt, ind)
Definition basics.h:586
TBCI__
#define TBCI__
Definition basics.h:332
REGISTER
#define REGISTER
Definition basics.h:108
MATH__
#define MATH__
Definition basics.h:339
INST2
#define INST2(x, y)
Definition basics.h:239
NOINST
#define NOINST
Definition basics.h:244
ALIGN
#define ALIGN(x)
Definition basics.h:444
MIN_ALIGN
#define MIN_ALIGN
Definition basics.h:421
FGD
#define FGD
Definition basics.h:144
T
#define T
Definition bdmatlib.cc:20
BVector
provides basic Vector functionality but arithmetic operators (+=, - , *, /...).
Definition bvector.h:68
BVector::vecptr
T *const & vecptr() const
Definition bvector.h:147
BVector::size
unsigned long size() const HOT
Definition bvector.h:144
FS_Vector
Implementation of fixed sized Vectors (template argument) which is favorable for small Vectors,...
Definition fs_vector.h:63
FS_Vector::value_type
T value_type
Definition fs_vector.h:68
FS_Vector::minus
FS_Vector< dims, T > minus(const T &) const
Definition fs_vector.h:564
FS_Vector::operator-
FS_Vector< dims, T > operator-() const
Definition fs_vector.h:365
FS_Vector::contains
bool contains(const T &, unsigned long *=0) const
Definition fs_vector.h:428
FS_Vector::sum
T sum() const
Definition fs_vector.h:461
FS_Vector::init_0
FS_Vector< dims, T > & init_0()
Definition fs_vector.h:100
FS_Vector::fabssqr
double fabssqr() const
Definition fs_vector.h:481
FS_Vector::operator<
bool operator<(const FS_Vector< dims, T > &fv) const
Definition fs_vector.h:164
FS_Vector::operator/=
FS_Vector< dims, T > & operator/=(const T &)
Definition fs_vector.h:344
FS_Vector::operator==
bool operator==(const FS_Vector< dims, T > &) const
Definition fs_vector.h:270
FS_Vector::operator()
T & operator()(const unsigned long i)
Definition fs_vector.h:248
FS_Vector::fabs
double fabs() const
Definition fs_vector.h:487
FS_Vector::operator*
T & operator*()
Definition fs_vector.h:88
FS_Vector::element_type
T element_type
Definition fs_vector.h:69
FS_Vector::FS_Vector
FS_Vector()
Definition fs_vector.h:72
FS_Vector::operator!=
bool operator!=(const FS_Vector< dims, T > &fv) const
Definition fs_vector.h:115
FS_Vector::min
T min() const
Definition fs_vector.h:439
FS_Vector::FGD
friend T dot FGD(const FS_Vector< dims, T > &, const FS_Vector< dims, T > &)
FS_Vector::FS_Vector
FS_Vector(const T v)
Definition fs_vector.h:73
FS_Vector::operator+
FS_Vector< dims, T > operator+(const FS_Vector< dims, T > &) const
Definition fs_vector.h:311
FS_Vector::incr
FS_Vector< dims, T > incr(const unsigned long, const T=(T) 1) const
Definition fs_vector.h:375
FS_Vector::operator>=
bool operator>=(const FS_Vector< dims, T > &fv) const
Definition fs_vector.h:162
FS_Vector::operator/
FS_Vector< dims, T > operator/(const T &) const
Definition fs_vector.h:354
FS_Vector::vecptr
T * vecptr() const
Definition fs_vector.h:190
FS_Vector::size
unsigned long size() const
Definition fs_vector.h:106
FS_Vector::x
T x[dims]
Definition fs_vector.h:65
FS_Vector::FS_Vector
FS_Vector(const FS_Vector< dims, U > &fsv)
Definition fs_vector.h:96
FS_Vector::max
T max() const
Definition fs_vector.h:450
FS_Vector::FS_Vector
friend class FS_Vector
Definition fs_vector.h:94
FS_Vector::operator<=
bool operator<=(const FS_Vector< dims, T > &fv) const
Definition fs_vector.h:160
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 &)
Definition fs_vector.h:325
FS_Vector::TALIGN
T aligned_value_type TALIGN(MIN_ALIGN)
Definition fs_vector.h:70
FS_Vector::operator+=
FS_Vector< dims, T > & operator+=(const FS_Vector< dims, T > &)
Definition fs_vector.h:298
FS_Vector::FS_Vector
FS_Vector(const FS_Vector< dims, T > &pc)
Definition fs_vector.h:74
FS_Vector::operator>
bool operator>(const FS_Vector< dims, T > &fv) const
Definition fs_vector.h:166
FS_Vector::plus
FS_Vector< dims, T > plus(const T &) const
Definition fs_vector.h:563
FS_Vector::get_fortran_vector
T * get_fortran_vector() const
Definition fs_vector.h:191
FS_Vector::fill
FS_Vector< dims, T > & fill(const T &)
Definition fs_vector.h:255
FS_Vector::operator=
FS_Vector< dims, T > & operator=(const T &a)
Definition fs_vector.h:109
FS_Vector::abs
T abs() const
Definition fs_vector.h:493
FS_Vector::clear
FS_Vector< dims, T > & clear()
Definition fs_vector.h:104
FS_Vector::operator[]
T & operator[](const unsigned long i)
Definition fs_vector.h:236
FS_Vector::operator-=
FS_Vector< dims, T > & operator-=(const FS_Vector< dims, T > &)
Definition fs_vector.h:299
FSVecErr
exception class
Definition fs_vector.h:28
FSVecErr::FSVecErr
FSVecErr(const FSVecErr &fe)
Definition fs_vector.h:34
FSVecErr::~FSVecErr
virtual ~FSVecErr()
Definition fs_vector.h:36
FSVecErr::FSVecErr
FSVecErr(const char *t, const long i=0)
Definition fs_vector.h:32
NumErr::NumErr
NumErr()
Definition except.h:65
Vector_Sig::Vector_Sig
Vector_Sig()
Definition vector_sig.h:76
fabs
double fabs(const TBCI__ cplx< T > &c)
Definition cplx.h:746
fabssqr
double fabssqr(const cplx< T > &c)
Definition cplx.h:390
conj
NAMESPACE_END NAMESPACE_CPLX TBCI__ cplx< T > conj(const TBCI__ cplx< T > &c)
Definition cplx.h:663
sqrt
NAMESPACE_END NAMESPACE_CSTD TBCI__ cplx< T > sqrt(const TBCI__ cplx< T > &z)
Definition cplx.h:751
abs
#define abs(x)
Definition f2c.h:178
min
#define min(a, b)
Definition f2c.h:180
max
#define max(a, b)
Definition f2c.h:181
FSV_ASS_T
#define FSV_ASS_T(op)
Definition fs_vector.h:314
cediv
FS_Vector< dims, T > cediv(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition fs_vector.h:537
sum
T sum(const FS_Vector< dims, T > &fv)
Definition fs_vector.h:599
operator<<
STD__ ostream & operator<<(STD__ ostream &os, const FS_Vector< dims, T > &fv)
Definition fs_vector.h:385
dot
T dot(const FS_Vector< dims, T > &fv1, const FS_Vector< dims, T > &fv2)
Definition fs_vector.h:471
FSV_ASS_FSV
#define FSV_ASS_FSV(op)
Definition fs_vector.h:289
fabssqr
double fabssqr(const FS_Vector< dims, T > &fv)
Definition fs_vector.h:548
operator>>
STD__ istream & operator>>(STD__ istream &in, FS_Vector< dims, T > &v)
Definition fs_vector.h:396
ediv
FS_Vector< dims, T > ediv(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition fs_vector.h:528
FSV_NOASS_T
#define FSV_NOASS_T(op)
Definition fs_vector.h:328
FSV_MEM_FRD
#define FSV_MEM_FRD(nm, op)
Definition fs_vector.h:552
FSV_NOASS_FSV
#define FSV_NOASS_FSV(op)
Definition fs_vector.h:301
emul
FS_Vector< dims, T > emul(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition fs_vector.h:510
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
cemul
FS_Vector< dims, T > cemul(const FS_Vector< dims, T > &f1, const FS_Vector< dims, T > &f2)
Definition fs_vector.h:519
dims
#define dims
Definition fsveclib.cc:24
a
const unsigned TMatrix< T > const Matrix< T > * a
Definition matrix_kernels.h:26
res
const unsigned TMatrix< T > * res
Definition matrix_kernels.h:26
CPLX__
real
#define real
Definition own_lapack_routines.cpp:20
Generated by doxygen 1.16.1