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) noexcept;
37 
38  template <class V,class S>
39  TINLINE void _vresize(V &rv, const int &len)
40 #if(CXSC_INDEX_CHECK)
41  ;
42 #else
43  noexcept;
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  ;
50 #else
51  noexcept;
52 #endif
53 
54  template <class V1,class V2,class S>
55  TINLINE V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
56 
57  template <class V,class S>
58  TINLINE V & _vsassign(V &rv,const S &r) noexcept;
59 
60  template <class VS1,class VS2>
61  TINLINE VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
62 #if(CXSC_INDEX_CHECK)
63  ;
64 #else
65  noexcept;
66 #endif
67 
68  template <class V,class VS,class S>
69  TINLINE V & _vvsassign(V &rv,const VS &sl) noexcept;
70 
71  template <class VS,class V>
72  TINLINE VS & _vsvassign(VS &sl,const V &rv)
73 #if(CXSC_INDEX_CHECK)
74  ;
75 #else
76  noexcept;
77 #endif
78 
79  template <class VS,class S>
80  TINLINE VS & _vssassign(VS &sl,const S &r) noexcept;
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  ;
86 #else
87  noexcept;
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  ;
94 #else
95  noexcept;
96 #endif
97 
98  template <class V,class S,class E>
99  TINLINE E _vsdiv(const V &rv, const S &s) noexcept;
100 
101  template <class V,class S>
102  TINLINE V &_vsdivassign(V &rv,const S &r) noexcept;
103 
104  template <class VS,class S,class E>
105  TINLINE E _vssdiv(const VS &sl, const S &s) noexcept;
106 
107  template <class V,class S,class E>
108  TINLINE E _vsmult(const V &rv, const S &s) noexcept;
109 
110  template <class VS,class S,class E>
111  TINLINE E _vssmult(const VS &sl, const S &s) noexcept;
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  ;
117 #else
118  noexcept;
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  ;
125 #else
126  noexcept;
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  ;
133 #else
134  noexcept;
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  ;
141 #else
142  noexcept;
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  ;
149 #else
150  noexcept;
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  ;
157 #else
158  noexcept;
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  ;
165 #else
166  noexcept;
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  ;
173 #else
174  noexcept;
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  ;
181 #else
182  noexcept;
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  ;
189 #else
190  noexcept;
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  ;
197 #else
198  noexcept;
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  ;
205 #else
206  noexcept;
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  ;
213 #else
214  noexcept;
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  ;
221 #else
222  noexcept;
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  ;
229 #else
230  noexcept;
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  ;
237 #else
238  noexcept;
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  ;
245 #else
246  noexcept;
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  ;
253 #else
254  noexcept;
255 #endif
256 
257  template <class V,class S>
258  TINLINE V &_vsmultassign(V &rv,const S &r) noexcept;
259 
260  template <class VS,class S>
261  TINLINE VS &_vssmultassign(VS &rv,const S &r) noexcept;
262 
263  template <class VS,class S>
264  TINLINE VS &_vssdivassign(VS &rv,const S &r) noexcept;
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  ;
270 #else
271  noexcept;
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  ;
278 #else
279  noexcept;
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  ;
286 #else
287  noexcept;
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  ;
294 #else
295  noexcept;
296 #endif
297 
298  template <class V1,class V2>
299  TINLINE V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
300 #if(CXSC_INDEX_CHECK)
301  ;
302 #else
303  noexcept;
304 #endif
305 
306  template <class V,class VS>
307  TINLINE V &_vvsplusassign(V &rv, const VS &sl)
308 #if(CXSC_INDEX_CHECK)
309  ;
310 #else
311  noexcept;
312 #endif
313 
314  template <class VS,class V>
315  TINLINE VS &_vsvplusassign(VS &sl, const V &rv)
316 #if(CXSC_INDEX_CHECK)
317  ;
318 #else
319  noexcept;
320 #endif
321 
322  template <class VS1,class VS2>
323  TINLINE VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
324 #if(CXSC_INDEX_CHECK)
325  ;
326 #else
327  noexcept;
328 #endif
329 
330  template <class VS1,class VS2>
331  TINLINE VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
332 #if(CXSC_INDEX_CHECK)
333  ;
334 #else
335  noexcept;
336 #endif
337 
338  template <class V1,class V2>
339  TINLINE V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
340 #if(CXSC_INDEX_CHECK)
341  ;
342 #else
343  noexcept;
344 #endif
345 
346  template <class V,class VS>
347  TINLINE V &_vvsminusassign(V &rv, const VS &sl)
348 #if(CXSC_INDEX_CHECK)
349  ;
350 #else
351  noexcept;
352 #endif
353 
354  template <class VS,class V>
355  TINLINE VS &_vsvminusassign(VS &sl, const V &rv)
356 #if(CXSC_INDEX_CHECK)
357  ;
358 #else
359  noexcept;
360 #endif
361 
362  template <class V>
363  TINLINE V _vminus(const V &rv) noexcept;
364 
365  template <class VS,class V>
366  TINLINE V _vsminus(const VS &sl) noexcept;
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  ;
372 #else
373  noexcept;
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  ;
380 #else
381  noexcept;
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  ;
388 #else
389  noexcept;
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  ;
396 #else
397  noexcept;
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  ;
404 #else
405  noexcept;
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  ;
412 #else
413  noexcept;
414 #endif
415 
416  template <class V1,class V2>
417  TINLINE V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
418 #if(CXSC_INDEX_CHECK)
419  ;
420 #else
421  noexcept;
422 #endif
423 
424  template <class V,class VS>
425  TINLINE V &_vvsconvassign(V &rv, const VS &sl)
426 #if(CXSC_INDEX_CHECK)
427  ;
428 #else
429  noexcept;
430 #endif
431 
432  template <class VS,class V>
433  TINLINE VS &_vsvconvassign(VS &sl, const V &rv)
434 #if(CXSC_INDEX_CHECK)
435  ;
436 #else
437  noexcept;
438 #endif
439 
440  template <class VS1,class VS2>
441  TINLINE VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
442 #if(CXSC_INDEX_CHECK)
443  ;
444 #else
445  noexcept;
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  ;
452 #else
453  noexcept;
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  ;
460 #else
461  noexcept;
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  ;
468 #else
469  noexcept;
470 #endif
471 
472  template <class V1,class V2>
473  TINLINE V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
474 #if(CXSC_INDEX_CHECK)
475  ;
476 #else
477  noexcept;
478 #endif
479 
480  template <class V,class VS>
481  TINLINE V &_vvssectassign(V &rv, const VS &sl)
482 #if(CXSC_INDEX_CHECK)
483  ;
484 #else
485  noexcept;
486 #endif
487 
488  template <class VS,class V>
489  TINLINE VS &_vsvsectassign(VS &sl, const V &rv)
490 #if(CXSC_INDEX_CHECK)
491  ;
492 #else
493  noexcept;
494 #endif
495 
496  template <class VS1,class VS2>
497  TINLINE VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
498 #if(CXSC_INDEX_CHECK)
499  ;
500 #else
501  noexcept;
502 #endif
503 
504  template <class V1,class V2>
505  TINLINE bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
506 
507  template <class VS,class V>
508  TINLINE bool _vsveq(const VS &sl, const V &rv) noexcept;
509 
510  template <class V1,class V2>
511  TINLINE bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
512 
513  template <class VS,class V>
514  TINLINE bool _vsvneq(const VS &sl, const V &rv) noexcept;
515 
516  template <class V1,class V2>
517  TINLINE bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
518 
519  template <class VS,class V>
520  TINLINE bool _vsvless(const VS &sl, const V &rv) noexcept;
521 
522  template <class V1,class V2>
523  TINLINE bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
524 
525  template <class VS,class V>
526  TINLINE bool _vsvleq(const VS &sl, const V &rv) noexcept;
527 
528  template <class V,class VS>
529  TINLINE bool _vvsless(const V &rv, const VS &sl) noexcept;
530 
531  template <class V,class VS>
532  TINLINE bool _vvsleq(const V &rv, const VS &sl) noexcept;
533 
534  template <class V>
535  TINLINE bool _vnot(const V &rv) noexcept;
536 
537  template <class V>
538  TINLINE void *_vvoid(const V &rv) noexcept;
539 
540  template <class V>
541  TINLINE V _vconj(const V &rv) noexcept;
542 
543  template <class VS,class E>
544  TINLINE E _vsconj(const VS &sl) noexcept;
545 
546  template <class V,class E>
547  TINLINE E _vabs(const V &rv) noexcept;
548 
549  template <class VS,class E>
550  TINLINE E _vsabs(const VS &sl) noexcept;
551 
552  template <class V,class E>
553  TINLINE E _vdiam(const V &rv) noexcept;
554 
555  template <class VS,class E>
556  TINLINE E _vsdiam(const VS &sl) noexcept;
557 
558  template <class V,class E>
559  TINLINE E _vmid(const V &rv) noexcept;
560 
561  template <class VS,class E>
562  TINLINE E _vsmid(const VS &sl) noexcept;
563 
564  template <class V,class E>
565  TINLINE E _vinf(const V &rv) noexcept;
566 
567  template <class VS,class E>
568  TINLINE E _vsinf(const VS &sl) noexcept;
569 
570  template <class V,class E>
571  TINLINE E _vsup(const V &rv) noexcept;
572 
573  template <class VS,class E>
574  TINLINE E _vssup(const VS &sl) noexcept;
575 
576  template <class V,class E>
577  TINLINE E _vre(const V &rv) noexcept;
578 
579  template <class VS,class E>
580  TINLINE E _vsre(const VS &sl) noexcept;
581 
582  template <class V,class E>
583  TINLINE E _vim(const V &rv) noexcept;
584 
585  template <class VS,class E>
586  TINLINE E _vsim(const VS &sl) noexcept;
587 
588  template <class V,class S>
589  TINLINE V &_vsusetsup(V &v, const S &s) noexcept;
590 
591  template <class V,class S>
592  TINLINE V &_vsusetinf(V &v, const S &s) noexcept;
593 
594  template <class V,class S>
595  TINLINE V &_vssetinf(V &v, const S &s) noexcept;
596 
597  template <class V,class S>
598  TINLINE V &_vssetsup(V &v, const S &s) noexcept;
599 
600  template <class V,class S>
601  TINLINE V &_vssetre(V &v, const S &s) noexcept;
602 
603  template <class V,class S>
604  TINLINE V &_vssetim(V &v, const S &s) noexcept;
605 
606  template <class VS,class S>
607  TINLINE VS &_vssusetsup(VS &vs, const S &s) noexcept;
608 
609  template <class VS,class S>
610  TINLINE VS &_vssusetinf(VS &vs, const S &s) noexcept;
611 
612  template <class VS,class S>
613  TINLINE VS &_vsssetinf(VS &vs, const S &s) noexcept;
614 
615  template <class VS,class S>
616  TINLINE VS &_vsssetsup(VS &vs, const S &s) noexcept;
617 
618  template <class VS,class S>
619  TINLINE VS &_vsssetre(VS &vs, const S &s) noexcept;
620 
621  template <class VS,class S>
622  TINLINE VS &_vsssetim(VS &vs, const S &s) noexcept;
623 
624  template <class V1,class V2>
625  TINLINE V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
626 #if(CXSC_INDEX_CHECK)
627  ;
628 #else
629  noexcept;
630 #endif
631 
632  template <class V,class VS>
633  TINLINE V &_vvssetinf(V &rv, const VS &sl)
634 #if(CXSC_INDEX_CHECK)
635  ;
636 #else
637  noexcept;
638 #endif
639 
640  template <class VS,class V>
641  TINLINE VS &_vsvsetinf(VS &sl, const V &rv)
642 #if(CXSC_INDEX_CHECK)
643  ;
644 #else
645  noexcept;
646 #endif
647 
648  template <class VS1,class VS2>
649  TINLINE VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
650 #if(CXSC_INDEX_CHECK)
651  ;
652 #else
653  noexcept;
654 #endif
655 
656  template <class V1,class V2>
657  TINLINE V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
658 #if(CXSC_INDEX_CHECK)
659  ;
660 #else
661  noexcept;
662 #endif
663 
664  template <class V,class VS>
665  TINLINE V &_vvssetsup(V &rv, const VS &sl)
666 #if(CXSC_INDEX_CHECK)
667  ;
668 #else
669  noexcept;
670 #endif
671 
672  template <class VS,class V>
673  TINLINE VS &_vsvsetsup(VS &sl, const V &rv)
674 #if(CXSC_INDEX_CHECK)
675  ;
676 #else
677  noexcept;
678 #endif
679 
680  template <class VS1,class VS2>
681  TINLINE VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
682 #if(CXSC_INDEX_CHECK)
683  ;
684 #else
685  noexcept;
686 #endif
687 
688  template <class V1,class V2>
689  TINLINE V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
690 #if(CXSC_INDEX_CHECK)
691  ;
692 #else
693  noexcept;
694 #endif
695 
696  template <class V,class VS>
697  TINLINE V &_vvsusetinf(V &rv, const VS &sl)
698 #if(CXSC_INDEX_CHECK)
699  ;
700 #else
701  noexcept;
702 #endif
703 
704  template <class VS,class V>
705  TINLINE VS &_vsvusetinf(VS &sl, const V &rv)
706 #if(CXSC_INDEX_CHECK)
707  ;
708 #else
709  noexcept;
710 #endif
711 
712  template <class VS1,class VS2>
713  TINLINE VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
714 #if(CXSC_INDEX_CHECK)
715  ;
716 #else
717  noexcept;
718 #endif
719 
720  template <class V1,class V2>
721  TINLINE V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
722 #if(CXSC_INDEX_CHECK)
723  ;
724 #else
725  noexcept;
726 #endif
727 
728  template <class V,class VS>
729  TINLINE V &_vvsusetsup(V &rv, const VS &sl)
730 #if(CXSC_INDEX_CHECK)
731  ;
732 #else
733  noexcept;
734 #endif
735 
736  template <class VS,class V>
737  TINLINE VS &_vsvusetsup(VS &sl, const V &rv)
738 #if(CXSC_INDEX_CHECK)
739  ;
740 #else
741  noexcept;
742 #endif
743 
744  template <class VS1,class VS2>
745  TINLINE VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
746 #if(CXSC_INDEX_CHECK)
747  ;
748 #else
749  noexcept;
750 #endif
751 
752  template <class V1,class V2>
753  TINLINE V1 &_vvsetim(V1 &rv1, const V2 &rv2)
754 #if(CXSC_INDEX_CHECK)
755  ;
756 #else
757  noexcept;
758 #endif
759 
760  template <class V,class VS>
761  TINLINE V &_vvssetim(V &rv, const VS &sl)
762 #if(CXSC_INDEX_CHECK)
763  ;
764 #else
765  noexcept;
766 #endif
767 
768  template <class VS,class V>
769  TINLINE VS &_vsvsetim(VS &sl, const V &rv)
770 #if(CXSC_INDEX_CHECK)
771  ;
772 #else
773  noexcept;
774 #endif
775 
776  template <class VS1,class VS2>
777  TINLINE VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
778 #if(CXSC_INDEX_CHECK)
779  ;
780 #else
781  noexcept;
782 #endif
783 
784  template <class V1,class V2>
785  TINLINE V1 &_vvsetre(V1 &rv1, const V2 &rv2)
786 #if(CXSC_INDEX_CHECK)
787  ;
788 #else
789  noexcept;
790 #endif
791 
792  template <class V,class VS>
793  TINLINE V &_vvssetre(V &rv, const VS &sl)
794 #if(CXSC_INDEX_CHECK)
795  ;
796 #else
797  noexcept;
798 #endif
799 
800  template <class VS,class V>
801  TINLINE VS &_vsvsetre(VS &sl, const V &rv)
802 #if(CXSC_INDEX_CHECK)
803  ;
804 #else
805  noexcept;
806 #endif
807 
808  template <class VS1,class VS2>
809  TINLINE VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
810 #if(CXSC_INDEX_CHECK)
811  ;
812 #else
813  noexcept;
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  ;
820 #else
821  noexcept;
822 #endif
823 
824  template <class VS1,class VS2>
825  TINLINE bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
826 
827  template <class VS1,class VS2>
828  TINLINE bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
829 
830  template <class VS1,class VS2>
831  TINLINE bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
832 
833  template <class VS1,class VS2>
834  TINLINE bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
835 
836  template <class VS>
837  TINLINE bool _vsnot(const VS &sl) noexcept;
838 
839  template <class VS>
840  TINLINE void *_vsvoid(const VS &sl) noexcept;
841 
842  template <class V>
843  std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
844 
845  template <class V>
846  std::istream &_vin(std::istream &s, V &rv) noexcept;
847 
848  template <class V>
849  std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
850 
851  template <class V>
852  std::istream &_vsin(std::istream &s, V &rv) noexcept;
853 
854 } // namespace cxsc
855 
856 #endif
857 
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29