C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
vector.hpp
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: vector.hpp,v 1.24 2014/01/30 17:23:49 cxsc Exp $ */
25 
26 #ifndef _CXSC_VECTOR_HPP_INCLUDED
27 #define _CXSC_VECTOR_HPP_INCLUDED
28 
29 #include "except.hpp"
30 #include "matrix.hpp" // there are the definitions matrix x vector
31 
32 namespace cxsc {
33 
34 
35  template <class V>
36  TINLINE void _vresize(V &rv) throw();
37 
38  template <class V,class S>
39  TINLINE void _vresize(V &rv, const int &len)
40 #if(CXSC_INDEX_CHECK)
41  throw(ERROR__WRONG_BOUNDARIES<V>);
42 #else
43  throw();
44 #endif
45 
46  template <class V,class S>
47  TINLINE void _vresize(V &rv, const int &lb, const int &ub)
48 #if(CXSC_INDEX_CHECK)
49  throw(ERROR__WRONG_BOUNDARIES<V>);
50 #else
51  throw();
52 #endif
53 
54  template <class V1,class V2,class S>
55  TINLINE V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
56 
57  template <class V,class S>
58  TINLINE V & _vsassign(V &rv,const S &r) throw();
59 
60  template <class VS1,class VS2>
61  TINLINE VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
62 #if(CXSC_INDEX_CHECK)
63  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
64 #else
65  throw();
66 #endif
67 
68  template <class V,class VS,class S>
69  TINLINE V & _vvsassign(V &rv,const VS &sl) throw();
70 
71  template <class VS,class V>
72  TINLINE VS & _vsvassign(VS &sl,const V &rv)
73 #if(CXSC_INDEX_CHECK)
74  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
75 #else
76  throw();
77 #endif
78 
79  template <class VS,class S>
80  TINLINE VS & _vssassign(VS &sl,const S &r) throw();
81 
82  template <class DP,class V1,class V2>
83  TINLINE void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
84 #if(CXSC_INDEX_CHECK)
85  throw(OP_WITH_WRONG_DIM);
86 #else
87  throw();
88 #endif
89 
90  template <class DP,class VS,class V>
91  TINLINE void _vsvaccu(DP &dp, const VS & sl, const V &rv)
92 #if(CXSC_INDEX_CHECK)
93  throw(OP_WITH_WRONG_DIM);
94 #else
95  throw();
96 #endif
97 
98  template <class V,class S,class E>
99  TINLINE E _vsdiv(const V &rv, const S &s) throw();
100 
101  template <class V,class S>
102  TINLINE V &_vsdivassign(V &rv,const S &r) throw();
103 
104  template <class VS,class S,class E>
105  TINLINE E _vssdiv(const VS &sl, const S &s) throw();
106 
107  template <class V,class S,class E>
108  TINLINE E _vsmult(const V &rv, const S &s) throw();
109 
110  template <class VS,class S,class E>
111  TINLINE E _vssmult(const VS &sl, const S &s) throw();
112 
113  template <class V1,class V2,class E>
114  TINLINE E _vvlmult(const V1 & rv1, const V2 &rv2)
115 #if(CXSC_INDEX_CHECK)
116  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
117 #else
118  throw();
119 #endif
120 
121  template <class VS,class V,class E>
122  TINLINE E _vsvlmult(const VS & sl, const V &rv)
123 #if(CXSC_INDEX_CHECK)
124  throw(ERROR__OP_WITH_WRONG_DIM<V>);
125 #else
126  throw();
127 #endif
128 
129  template <class VS1,class VS2,class E>
130  TINLINE E _vsvslmult(const VS1 & sl1, const VS2 &sl2)
131 #if(CXSC_INDEX_CHECK)
132  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
133 #else
134  throw();
135 #endif
136 
137  template <class V1,class V2,class E>
138  TINLINE E _vvlimult(const V1 & rv1, const V2 &rv2)
139 #if(CXSC_INDEX_CHECK)
140  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
141 #else
142  throw();
143 #endif
144 
145  template <class VS,class V,class E>
146  TINLINE E _vsvlimult(const VS & sl, const V &rv)
147 #if(CXSC_INDEX_CHECK)
148  throw(ERROR__OP_WITH_WRONG_DIM<V>);
149 #else
150  throw();
151 #endif
152 
153  template <class VS1,class VS2,class E>
154  TINLINE E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
155 #if(CXSC_INDEX_CHECK)
156  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
157 #else
158  throw();
159 #endif
160 
161  template <class V1,class V2,class E>
162  TINLINE E _vvmult(const V1 & rv1, const V2 &rv2)
163 #if(CXSC_INDEX_CHECK)
164  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
165 #else
166  throw();
167 #endif
168 
169  template <class VS,class V,class E>
170  TINLINE E _vsvmult(const VS & sl, const V &rv)
171 #if(CXSC_INDEX_CHECK)
172  throw(ERROR__OP_WITH_WRONG_DIM<V>);
173 #else
174  throw();
175 #endif
176 
177  template <class VS1,class VS2,class E>
178  TINLINE E _vsvsmult(const VS1 & sl1, const VS2 &sl2)
179 #if(CXSC_INDEX_CHECK)
180  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
181 #else
182  throw();
183 #endif
184 
185  template <class V1,class V2,class E>
186  TINLINE E _vvimult(const V1 & rv1, const V2 &rv2)
187 #if(CXSC_INDEX_CHECK)
188  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
189 #else
190  throw();
191 #endif
192 
193  template <class VS,class V,class E>
194  TINLINE E _vsvimult(const VS & sl, const V &rv)
195 #if(CXSC_INDEX_CHECK)
196  throw(ERROR__OP_WITH_WRONG_DIM<V>);
197 #else
198  throw();
199 #endif
200 
201  template <class VS1,class VS2,class E>
202  TINLINE E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
203 #if(CXSC_INDEX_CHECK)
204  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
205 #else
206  throw();
207 #endif
208 
209  template <class V1,class V2,class E>
210  TINLINE E _vvcmult(const V1 & rv1, const V2 &rv2)
211 #if(CXSC_INDEX_CHECK)
212  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
213 #else
214  throw();
215 #endif
216 
217  template <class VS,class V,class E>
218  TINLINE E _vsvcmult(const VS & sl, const V &rv)
219 #if(CXSC_INDEX_CHECK)
220  throw(ERROR__OP_WITH_WRONG_DIM<V>);
221 #else
222  throw();
223 #endif
224 
225  template <class VS1,class VS2,class E>
226  TINLINE E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
227 #if(CXSC_INDEX_CHECK)
228  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
229 #else
230  throw();
231 #endif
232 
233  template <class V1,class V2,class E>
234  TINLINE E _vvcimult(const V1 & rv1, const V2 &rv2)
235 #if(CXSC_INDEX_CHECK)
236  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
237 #else
238  throw();
239 #endif
240 
241  template <class VS,class V,class E>
242  TINLINE E _vsvcimult(const VS & sl, const V &rv)
243 #if(CXSC_INDEX_CHECK)
244  throw(ERROR__OP_WITH_WRONG_DIM<V>);
245 #else
246  throw();
247 #endif
248 
249  template <class VS1,class VS2,class E>
250  TINLINE E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
251 #if(CXSC_INDEX_CHECK)
252  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
253 #else
254  throw();
255 #endif
256 
257  template <class V,class S>
258  TINLINE V &_vsmultassign(V &rv,const S &r) throw();
259 
260  template <class VS,class S>
261  TINLINE VS &_vssmultassign(VS &rv,const S &r) throw();
262 
263  template <class VS,class S>
264  TINLINE VS &_vssdivassign(VS &rv,const S &r) throw();
265 
266  template <class V1,class V2,class E>
267  TINLINE E _vvplus(const V1 &rv1, const V2 &rv2)
268 #if(CXSC_INDEX_CHECK)
269  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
270 #else
271  throw();
272 #endif
273 
274  template <class V,class VS,class E>
275  TINLINE E _vvsplus(const V &rv,const VS &sl)
276 #if(CXSC_INDEX_CHECK)
277  throw(ERROR__OP_WITH_WRONG_DIM<V>);
278 #else
279  throw();
280 #endif
281 
282  template <class VS1,class VS2,class E>
283  TINLINE E _vsvsplus(const VS1 &s1,const VS2 &s2)
284 #if(CXSC_INDEX_CHECK)
285  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
286 #else
287  throw();
288 #endif
289 
290  template <class VS1,class VS2,class E>
291  TINLINE E _vsvsminus(const VS1 &s1,const VS2 &s2)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
294 #else
295  throw();
296 #endif
297 
298  template <class V1,class V2>
299  TINLINE V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
300 #if(CXSC_INDEX_CHECK)
301  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
302 #else
303  throw();
304 #endif
305 
306  template <class V,class VS>
307  TINLINE V &_vvsplusassign(V &rv, const VS &sl)
308 #if(CXSC_INDEX_CHECK)
309  throw(ERROR__OP_WITH_WRONG_DIM<V>);
310 #else
311  throw();
312 #endif
313 
314  template <class VS,class V>
315  TINLINE VS &_vsvplusassign(VS &sl, const V &rv)
316 #if(CXSC_INDEX_CHECK)
317  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
318 #else
319  throw();
320 #endif
321 
322  template <class VS1,class VS2>
323  TINLINE VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
324 #if(CXSC_INDEX_CHECK)
325  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
326 #else
327  throw();
328 #endif
329 
330  template <class VS1,class VS2>
331  TINLINE VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
332 #if(CXSC_INDEX_CHECK)
333  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
334 #else
335  throw();
336 #endif
337 
338  template <class V1,class V2>
339  TINLINE V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
340 #if(CXSC_INDEX_CHECK)
341  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
342 #else
343  throw();
344 #endif
345 
346  template <class V,class VS>
347  TINLINE V &_vvsminusassign(V &rv, const VS &sl)
348 #if(CXSC_INDEX_CHECK)
349  throw(ERROR__OP_WITH_WRONG_DIM<V>);
350 #else
351  throw();
352 #endif
353 
354  template <class VS,class V>
355  TINLINE VS &_vsvminusassign(VS &sl, const V &rv)
356 #if(CXSC_INDEX_CHECK)
357  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
358 #else
359  throw();
360 #endif
361 
362  template <class V>
363  TINLINE V _vminus(const V &rv) throw();
364 
365  template <class VS,class V>
366  TINLINE V _vsminus(const VS &sl) throw();
367 
368  template <class V1,class V2,class E>
369  TINLINE E _vvminus(const V1 &rv1, const V2 &rv2)
370 #if(CXSC_INDEX_CHECK)
371  throw(ERROR__OP_WITH_WRONG_DIM<E>);
372 #else
373  throw();
374 #endif
375 
376  template <class V,class VS,class E>
377  TINLINE E _vvsminus(const V &rv, const VS &sl)
378 #if(CXSC_INDEX_CHECK)
379  throw(ERROR__OP_WITH_WRONG_DIM<E>);
380 #else
381  throw();
382 #endif
383 
384  template <class VS,class V,class E>
385  TINLINE E _vsvminus(const VS &sl,const V &rv)
386 #if(CXSC_INDEX_CHECK)
387  throw(ERROR__OP_WITH_WRONG_DIM<E>);
388 #else
389  throw();
390 #endif
391 
392  template <class V1,class V2,class E>
393  TINLINE E _vvconv(const V1 &rv1, const V2 &rv2)
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR__OP_WITH_WRONG_DIM<E>);
396 #else
397  throw();
398 #endif
399 
400  template <class V,class VS,class E>
401  TINLINE E _vvsconv(const V &rv,const VS &sl)
402 #if(CXSC_INDEX_CHECK)
403  throw(ERROR__OP_WITH_WRONG_DIM<E>);
404 #else
405  throw();
406 #endif
407 
408  template <class VS1,class VS2,class E>
409  TINLINE E _vsvsconv(const VS1 &s1,const VS2 &s2)
410 #if(CXSC_INDEX_CHECK)
411  throw(ERROR__OP_WITH_WRONG_DIM<E>);
412 #else
413  throw();
414 #endif
415 
416  template <class V1,class V2>
417  TINLINE V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
418 #if(CXSC_INDEX_CHECK)
419  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
420 #else
421  throw();
422 #endif
423 
424  template <class V,class VS>
425  TINLINE V &_vvsconvassign(V &rv, const VS &sl)
426 #if(CXSC_INDEX_CHECK)
427  throw(ERROR__OP_WITH_WRONG_DIM<V>);
428 #else
429  throw();
430 #endif
431 
432  template <class VS,class V>
433  TINLINE VS &_vsvconvassign(VS &sl, const V &rv)
434 #if(CXSC_INDEX_CHECK)
435  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
436 #else
437  throw();
438 #endif
439 
440  template <class VS1,class VS2>
441  TINLINE VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
442 #if(CXSC_INDEX_CHECK)
443  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
444 #else
445  throw();
446 #endif
447 
448  template <class V1,class V2,class E>
449  TINLINE E _vvsect(const V1 &rv1, const V2 &rv2)
450 #if(CXSC_INDEX_CHECK)
451  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
452 #else
453  throw();
454 #endif
455 
456  template <class V,class VS,class E>
457  TINLINE E _vvssect(const V &rv,const VS &sl)
458 #if(CXSC_INDEX_CHECK)
459  throw(ERROR__OP_WITH_WRONG_DIM<E>);
460 #else
461  throw();
462 #endif
463 
464  template <class VS1,class VS2,class E>
465  TINLINE E _vsvssect(const VS1 &s1,const VS2 &s2)
466 #if(CXSC_INDEX_CHECK)
467  throw(ERROR__OP_WITH_WRONG_DIM<E>);
468 #else
469  throw();
470 #endif
471 
472  template <class V1,class V2>
473  TINLINE V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
474 #if(CXSC_INDEX_CHECK)
475  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
476 #else
477  throw();
478 #endif
479 
480  template <class V,class VS>
481  TINLINE V &_vvssectassign(V &rv, const VS &sl)
482 #if(CXSC_INDEX_CHECK)
483  throw(ERROR__OP_WITH_WRONG_DIM<V>);
484 #else
485  throw();
486 #endif
487 
488  template <class VS,class V>
489  TINLINE VS &_vsvsectassign(VS &sl, const V &rv)
490 #if(CXSC_INDEX_CHECK)
491  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
492 #else
493  throw();
494 #endif
495 
496  template <class VS1,class VS2>
497  TINLINE VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
498 #if(CXSC_INDEX_CHECK)
499  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
500 #else
501  throw();
502 #endif
503 
504  template <class V1,class V2>
505  TINLINE bool _vveq(const V1 &rv1, const V2 &rv2) throw();
506 
507  template <class VS,class V>
508  TINLINE bool _vsveq(const VS &sl, const V &rv) throw();
509 
510  template <class V1,class V2>
511  TINLINE bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
512 
513  template <class VS,class V>
514  TINLINE bool _vsvneq(const VS &sl, const V &rv) throw();
515 
516  template <class V1,class V2>
517  TINLINE bool _vvless(const V1 &rv1, const V2 &rv2) throw();
518 
519  template <class VS,class V>
520  TINLINE bool _vsvless(const VS &sl, const V &rv) throw();
521 
522  template <class V1,class V2>
523  TINLINE bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
524 
525  template <class VS,class V>
526  TINLINE bool _vsvleq(const VS &sl, const V &rv) throw();
527 
528  template <class V,class VS>
529  TINLINE bool _vvsless(const V &rv, const VS &sl) throw();
530 
531  template <class V,class VS>
532  TINLINE bool _vvsleq(const V &rv, const VS &sl) throw();
533 
534  template <class V>
535  TINLINE bool _vnot(const V &rv) throw();
536 
537  template <class V>
538  TINLINE void *_vvoid(const V &rv) throw();
539 
540  template <class V>
541  TINLINE V _vconj(const V &rv) throw();
542 
543  template <class VS,class E>
544  TINLINE E _vsconj(const VS &sl) throw();
545 
546  template <class V,class E>
547  TINLINE E _vabs(const V &rv) throw();
548 
549  template <class VS,class E>
550  TINLINE E _vsabs(const VS &sl) throw();
551 
552  template <class V,class E>
553  TINLINE E _vdiam(const V &rv) throw();
554 
555  template <class VS,class E>
556  TINLINE E _vsdiam(const VS &sl) throw();
557 
558  template <class V,class E>
559  TINLINE E _vmid(const V &rv) throw();
560 
561  template <class VS,class E>
562  TINLINE E _vsmid(const VS &sl) throw();
563 
564  template <class V,class E>
565  TINLINE E _vinf(const V &rv) throw();
566 
567  template <class VS,class E>
568  TINLINE E _vsinf(const VS &sl) throw();
569 
570  template <class V,class E>
571  TINLINE E _vsup(const V &rv) throw();
572 
573  template <class VS,class E>
574  TINLINE E _vssup(const VS &sl) throw();
575 
576  template <class V,class E>
577  TINLINE E _vre(const V &rv) throw();
578 
579  template <class VS,class E>
580  TINLINE E _vsre(const VS &sl) throw();
581 
582  template <class V,class E>
583  TINLINE E _vim(const V &rv) throw();
584 
585  template <class VS,class E>
586  TINLINE E _vsim(const VS &sl) throw();
587 
588  template <class V,class S>
589  TINLINE V &_vsusetsup(V &v, const S &s) throw();
590 
591  template <class V,class S>
592  TINLINE V &_vsusetinf(V &v, const S &s) throw();
593 
594  template <class V,class S>
595  TINLINE V &_vssetinf(V &v, const S &s) throw();
596 
597  template <class V,class S>
598  TINLINE V &_vssetsup(V &v, const S &s) throw();
599 
600  template <class V,class S>
601  TINLINE V &_vssetre(V &v, const S &s) throw();
602 
603  template <class V,class S>
604  TINLINE V &_vssetim(V &v, const S &s) throw();
605 
606  template <class VS,class S>
607  TINLINE VS &_vssusetsup(VS &vs, const S &s) throw();
608 
609  template <class VS,class S>
610  TINLINE VS &_vssusetinf(VS &vs, const S &s) throw();
611 
612  template <class VS,class S>
613  TINLINE VS &_vsssetinf(VS &vs, const S &s) throw();
614 
615  template <class VS,class S>
616  TINLINE VS &_vsssetsup(VS &vs, const S &s) throw();
617 
618  template <class VS,class S>
619  TINLINE VS &_vsssetre(VS &vs, const S &s) throw();
620 
621  template <class VS,class S>
622  TINLINE VS &_vsssetim(VS &vs, const S &s) throw();
623 
624  template <class V1,class V2>
625  TINLINE V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
626 #if(CXSC_INDEX_CHECK)
627  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
628 #else
629  throw();
630 #endif
631 
632  template <class V,class VS>
633  TINLINE V &_vvssetinf(V &rv, const VS &sl)
634 #if(CXSC_INDEX_CHECK)
635  throw(ERROR__OP_WITH_WRONG_DIM<V>);
636 #else
637  throw();
638 #endif
639 
640  template <class VS,class V>
641  TINLINE VS &_vsvsetinf(VS &sl, const V &rv)
642 #if(CXSC_INDEX_CHECK)
643  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
644 #else
645  throw();
646 #endif
647 
648  template <class VS1,class VS2>
649  TINLINE VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
650 #if(CXSC_INDEX_CHECK)
651  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
652 #else
653  throw();
654 #endif
655 
656  template <class V1,class V2>
657  TINLINE V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
658 #if(CXSC_INDEX_CHECK)
659  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
660 #else
661  throw();
662 #endif
663 
664  template <class V,class VS>
665  TINLINE V &_vvssetsup(V &rv, const VS &sl)
666 #if(CXSC_INDEX_CHECK)
667  throw(ERROR__OP_WITH_WRONG_DIM<V>);
668 #else
669  throw();
670 #endif
671 
672  template <class VS,class V>
673  TINLINE VS &_vsvsetsup(VS &sl, const V &rv)
674 #if(CXSC_INDEX_CHECK)
675  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
676 #else
677  throw();
678 #endif
679 
680  template <class VS1,class VS2>
681  TINLINE VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
682 #if(CXSC_INDEX_CHECK)
683  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
684 #else
685  throw();
686 #endif
687 
688  template <class V1,class V2>
689  TINLINE V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
690 #if(CXSC_INDEX_CHECK)
691  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
692 #else
693  throw();
694 #endif
695 
696  template <class V,class VS>
697  TINLINE V &_vvsusetinf(V &rv, const VS &sl)
698 #if(CXSC_INDEX_CHECK)
699  throw(ERROR__OP_WITH_WRONG_DIM<V>);
700 #else
701  throw();
702 #endif
703 
704  template <class VS,class V>
705  TINLINE VS &_vsvusetinf(VS &sl, const V &rv)
706 #if(CXSC_INDEX_CHECK)
707  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
708 #else
709  throw();
710 #endif
711 
712  template <class VS1,class VS2>
713  TINLINE VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
714 #if(CXSC_INDEX_CHECK)
715  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
716 #else
717  throw();
718 #endif
719 
720  template <class V1,class V2>
721  TINLINE V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
722 #if(CXSC_INDEX_CHECK)
723  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
724 #else
725  throw();
726 #endif
727 
728  template <class V,class VS>
729  TINLINE V &_vvsusetsup(V &rv, const VS &sl)
730 #if(CXSC_INDEX_CHECK)
731  throw(ERROR__OP_WITH_WRONG_DIM<V>);
732 #else
733  throw();
734 #endif
735 
736  template <class VS,class V>
737  TINLINE VS &_vsvusetsup(VS &sl, const V &rv)
738 #if(CXSC_INDEX_CHECK)
739  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
740 #else
741  throw();
742 #endif
743 
744  template <class VS1,class VS2>
745  TINLINE VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
746 #if(CXSC_INDEX_CHECK)
747  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
748 #else
749  throw();
750 #endif
751 
752  template <class V1,class V2>
753  TINLINE V1 &_vvsetim(V1 &rv1, const V2 &rv2)
754 #if(CXSC_INDEX_CHECK)
755  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
756 #else
757  throw();
758 #endif
759 
760  template <class V,class VS>
761  TINLINE V &_vvssetim(V &rv, const VS &sl)
762 #if(CXSC_INDEX_CHECK)
763  throw(ERROR__OP_WITH_WRONG_DIM<V>);
764 #else
765  throw();
766 #endif
767 
768  template <class VS,class V>
769  TINLINE VS &_vsvsetim(VS &sl, const V &rv)
770 #if(CXSC_INDEX_CHECK)
771  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
772 #else
773  throw();
774 #endif
775 
776  template <class VS1,class VS2>
777  TINLINE VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
778 #if(CXSC_INDEX_CHECK)
779  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
780 #else
781  throw();
782 #endif
783 
784  template <class V1,class V2>
785  TINLINE V1 &_vvsetre(V1 &rv1, const V2 &rv2)
786 #if(CXSC_INDEX_CHECK)
787  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
788 #else
789  throw();
790 #endif
791 
792  template <class V,class VS>
793  TINLINE V &_vvssetre(V &rv, const VS &sl)
794 #if(CXSC_INDEX_CHECK)
795  throw(ERROR__OP_WITH_WRONG_DIM<V>);
796 #else
797  throw();
798 #endif
799 
800  template <class VS,class V>
801  TINLINE VS &_vsvsetre(VS &sl, const V &rv)
802 #if(CXSC_INDEX_CHECK)
803  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
804 #else
805  throw();
806 #endif
807 
808  template <class VS1,class VS2>
809  TINLINE VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
810 #if(CXSC_INDEX_CHECK)
811  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
812 #else
813  throw();
814 #endif
815 
816  template <class DP,class VS1,class VS2>
817  TINLINE void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
818 #if(CXSC_INDEX_CHECK)
819  throw(OP_WITH_WRONG_DIM);
820 #else
821  throw();
822 #endif
823 
824  template <class VS1,class VS2>
825  TINLINE bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
826 
827  template <class VS1,class VS2>
828  TINLINE bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
829 
830  template <class VS1,class VS2>
831  TINLINE bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
832 
833  template <class VS1,class VS2>
834  TINLINE bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
835 
836  template <class VS>
837  TINLINE bool _vsnot(const VS &sl) throw();
838 
839  template <class VS>
840  TINLINE void *_vsvoid(const VS &sl) throw();
841 
842  template <class V>
843  std::ostream &_vout(std::ostream &s, const V &rv) throw();
844 
845  template <class V>
846  std::istream &_vin(std::istream &s, V &rv) throw();
847 
848  template <class V>
849  std::ostream &_vsout(std::ostream &s, const V &rv) throw();
850 
851  template <class V>
852  std::istream &_vsin(std::istream &s, V &rv) throw();
853 
854 } // namespace cxsc
855 
856 #endif
857 
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29