C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
ivector.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: ivector.hpp,v 1.36 2014/01/30 17:23:45 cxsc Exp $ */
25
26#ifndef _CXSC_IVECTOR_HPP_INCLUDED
27#define _CXSC_IVECTOR_HPP_INCLUDED
28
29#include "xscclass.hpp"
30#include "except.hpp"
31#include "idot.hpp"
32#include "cidot.hpp"
33#include "interval.hpp" // used for declaration of Inf, Sup,...
34#include "rvector.hpp"
35#include "vector.hpp"
36
37
38#include <iostream>
39
40namespace cxsc {
41
42class srvector;
43class srvector_slice;
44class sivector;
45class sivector_slice;
46class ivector_slice;
47
49
55{
56 friend class ivector_slice;
57 friend class imatrix;
58 friend class imatrix_subv;
59 friend class civector;
60 friend class cimatrix;
61 friend class l_ivector;
62 friend class l_imatrix;
63 private:
64 interval *dat;
65 int l,u,size;
66
67 public:
68//#if(CXSC_INDEX_CHECK)
69#ifdef _CXSC_FRIEND_TPL
70 //------------ Templates --------------------------------------------------
71 // Interval
72template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
73#if(CXSC_INDEX_CHECK)
74;
75#else
76 noexcept;
77#endif
78template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
79#if(CXSC_INDEX_CHECK)
80;
81#else
82 noexcept;
83#endif
84 template <class V> friend void _vresize(V &rv) noexcept;
85 template <class V,class S> friend void _vresize(V &rv, const int &len)
86#if(CXSC_INDEX_CHECK)
87 ;
88#else
89 noexcept;
90#endif
91 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
92#if(CXSC_INDEX_CHECK)
93 ;
94#else
95 noexcept;
96#endif
97 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
98 template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
99 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
100template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
101#if(CXSC_INDEX_CHECK)
102 ;
103#else
104 noexcept;
105#endif
106template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
107#if(CXSC_INDEX_CHECK)
108;
109#else
110 noexcept;
111#endif
112template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
113 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
114#if(CXSC_INDEX_CHECK)
115 ;
116#else
117 noexcept;
118#endif
119 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
120#if(CXSC_INDEX_CHECK)
121 ;
122#else
123 noexcept;
124#endif
125 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
126#if(CXSC_INDEX_CHECK)
127 ;
128#else
129 noexcept;
130#endif
131 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
132#if(CXSC_INDEX_CHECK)
133 ;
134#else
135 noexcept;
136#endif
137template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
138#if(CXSC_INDEX_CHECK)
139;
140#else
141 noexcept;
142#endif
143template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
144#if(CXSC_INDEX_CHECK)
145;
146#else
147 noexcept;
148#endif
149 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
150#if(CXSC_INDEX_CHECK)
151 ;
152#else
153 noexcept;
154#endif
155 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
156#if(CXSC_INDEX_CHECK)
157 ;
158#else
159 noexcept;
160#endif
161 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
162#if(CXSC_INDEX_CHECK)
163 ;
164#else
165 noexcept;
166#endif
167 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
168#if(CXSC_INDEX_CHECK)
169 ;
170#else
171 noexcept;
172#endif
173template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
174#if(CXSC_INDEX_CHECK)
175;
176#else
177 noexcept;
178#endif
179template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
180#if(CXSC_INDEX_CHECK)
181;
182#else
183 noexcept;
184#endif
185 template <class V,class S> friend V &_vssetinf(V &v, const S &s) noexcept;
186 template <class V,class S> friend V &_vssetsup(V &v, const S &s) noexcept;
187 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) noexcept;
188 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) noexcept;
189 template <class V,class E> friend E _vabs(const V &rv) noexcept;
190 template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
191template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
192 template <class V,class E> friend E _vdiam(const V &rv) noexcept;
193 template <class V,class E> friend E _vmid(const V &rv) noexcept;
194 template <class V,class E> friend E _vinf(const V &rv) noexcept;
195 template <class V,class E> friend E _vsup(const V &rv) noexcept;
196
197//-------- vector-vector -----------------------
198 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
199#if(CXSC_INDEX_CHECK)
200 ;
201#else
202 noexcept;
203#endif
204 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
205#if(CXSC_INDEX_CHECK)
206 ;
207#else
208 noexcept;
209#endif
210 template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2)
211#if(CXSC_INDEX_CHECK)
212 ;
213#else
214 noexcept;
215#endif
216 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
217#if(CXSC_INDEX_CHECK)
218 ;
219#else
220 noexcept;
221#endif
222 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
223 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
224#if(CXSC_INDEX_CHECK)
225 ;
226#else
227 noexcept;
228#endif
229 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
230#if(CXSC_INDEX_CHECK)
231 ;
232#else
233 noexcept;
234#endif
235 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
236#if(CXSC_INDEX_CHECK)
237 ;
238#else
239 noexcept;
240#endif
241 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
242#if(CXSC_INDEX_CHECK)
243 ;
244#else
245 noexcept;
246#endif
247 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
248#if(CXSC_INDEX_CHECK)
249 ;
250#else
251 noexcept;
252#endif
253 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
254#if(CXSC_INDEX_CHECK)
255 ;
256#else
257 noexcept;
258#endif
259 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
260#if(CXSC_INDEX_CHECK)
261 ;
262#else
263 noexcept;
264#endif
265 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
266#if(CXSC_INDEX_CHECK)
267 ;
268#else
269 noexcept;
270#endif
271 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
272#if(CXSC_INDEX_CHECK)
273 ;
274#else
275 noexcept;
276#endif
277 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
278#if(CXSC_INDEX_CHECK)
279 ;
280#else
281 noexcept;
282#endif
283 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
284#if(CXSC_INDEX_CHECK)
285 ;
286#else
287 noexcept;
288#endif
289 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
290#if(CXSC_INDEX_CHECK)
291 ;
292#else
293 noexcept;
294#endif
295 template <class V> friend V _vminus(const V &rv) noexcept;
296 template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
297 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
298#if(CXSC_INDEX_CHECK)
299 ;
300#else
301 noexcept;
302#endif
303 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
304#if(CXSC_INDEX_CHECK)
305 ;
306#else
307 noexcept;
308#endif
309 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
310#if(CXSC_INDEX_CHECK)
311 ;
312#else
313 noexcept;
314#endif
315 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
316#if(CXSC_INDEX_CHECK)
317 ;
318#else
319 noexcept;
320#endif
321 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
322#if(CXSC_INDEX_CHECK)
323 ;
324#else
325 noexcept;
326#endif
327 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
328#if(CXSC_INDEX_CHECK)
329 ;
330#else
331 noexcept;
332#endif
333 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
334#if(CXSC_INDEX_CHECK)
335 ;
336#else
337 noexcept;
338#endif
339 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
340#if(CXSC_INDEX_CHECK)
341 ;
342#else
343 noexcept;
344#endif
345 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
346#if(CXSC_INDEX_CHECK)
347 ;
348#else
349 noexcept;
350#endif
351 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
352#if(CXSC_INDEX_CHECK)
353 ;
354#else
355 noexcept;
356#endif
357 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
358#if(CXSC_INDEX_CHECK)
359 ;
360#else
361 noexcept;
362#endif
363 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
364#if(CXSC_INDEX_CHECK)
365 ;
366#else
367 noexcept;
368#endif
369 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
370#if(CXSC_INDEX_CHECK)
371 ;
372#else
373 noexcept;
374#endif
375 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
376#if(CXSC_INDEX_CHECK)
377 ;
378#else
379 noexcept;
380#endif
381 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
382#if(CXSC_INDEX_CHECK)
383 ;
384#else
385 noexcept;
386#endif
387 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
388#if(CXSC_INDEX_CHECK)
389 ;
390#else
391 noexcept;
392#endif
393 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
394#if(CXSC_INDEX_CHECK)
395 ;
396#else
397 noexcept;
398#endif
399 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
400#if(CXSC_INDEX_CHECK)
401 ;
402#else
403 noexcept;
404#endif
405 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
406#if(CXSC_INDEX_CHECK)
407 ;
408#else
409 noexcept;
410#endif
411template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
412#if(CXSC_INDEX_CHECK)
413;
414#else
415 noexcept;
416#endif
417template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
418#if(CXSC_INDEX_CHECK)
419;
420#else
421 noexcept;
422#endif
423 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
424#if(CXSC_INDEX_CHECK)
425 ;
426#else
427 noexcept;
428#endif
429 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
430#if(CXSC_INDEX_CHECK)
431 ;
432#else
433 noexcept;
434#endif
435template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
436#if(CXSC_INDEX_CHECK)
437;
438#else
439 noexcept;
440#endif
441template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
442#if(CXSC_INDEX_CHECK)
443;
444#else
445 noexcept;
446#endif
447 template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
448#if(CXSC_INDEX_CHECK)
449 ;
450#else
451 noexcept;
452#endif
453 //--------- vector-scalar -----------------
454 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
455 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
456 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
457 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
458 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
459 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
460 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
461#if(CXSC_INDEX_CHECK)
462 ;
463#else
464 noexcept;
465#endif
466 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
467#if(CXSC_INDEX_CHECK)
468 ;
469#else
470 noexcept;
471#endif
472 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
473#if(CXSC_INDEX_CHECK)
474 ;
475#else
476 noexcept;
477#endif
478 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
479#if(CXSC_INDEX_CHECK)
480 ;
481#else
482 noexcept;
483#endif
484 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
485#if(CXSC_INDEX_CHECK)
486 ;
487#else
488 noexcept;
489#endif
490template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
491#if(CXSC_INDEX_CHECK)
492;
493#else
494 noexcept;
495#endif
496template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
497#if(CXSC_INDEX_CHECK)
498;
499#else
500 noexcept;
501#endif
502 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
503template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
504#if(CXSC_INDEX_CHECK)
505;
506#else
507 noexcept;
508#endif
509
510 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
511 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
512 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
513 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
514 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
515 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
516 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
517 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
518 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
519 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
520 template <class V> friend bool _vnot(const V &rv) noexcept;
521 template <class V> friend void *_vvoid(const V &rv) noexcept;
522 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
523 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
524 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
525 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
526 template <class VS> friend bool _vsnot(const VS &sl) noexcept;
527 template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
528 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
529 template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
530
531 //------------- vector-matrix ---------------
532template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
533#if(CXSC_INDEX_CHECK)
534 ;
535#else
536 noexcept;
537#endif
538
539template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
540 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
541#if(CXSC_INDEX_CHECK)
542 ;
543#else
544 noexcept;
545#endif
546 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
547#if(CXSC_INDEX_CHECK)
548 ;
549#else
550 noexcept;
551#endif
552 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
553#if(CXSC_INDEX_CHECK)
554 ;
555#else
556 noexcept;
557#endif
558 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
559#if(CXSC_INDEX_CHECK)
560 ;
561#else
562 noexcept;
563#endif
564 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
565#if(CXSC_INDEX_CHECK)
566 ;
567#else
568 noexcept;
569#endif
570 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
571#if(CXSC_INDEX_CHECK)
572 ;
573#else
574 noexcept;
575#endif
576
577 // Real
578 //--Real -------- vector-scalar ------------
579 //--Real--------- Vector-vector---------
580 //-- Real -------- Vector-matrix ----------
581 // complex
582 //--complex -------- vector-scalar ------------
583 //--complex--------- Vector-vector---------
584
585 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
586#if(CXSC_INDEX_CHECK)
587 ;
588#else
589 noexcept;
590#endif
591 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
592#if(CXSC_INDEX_CHECK)
593 ;
594#else
595 noexcept;
596#endif
597
598 //-- complex -------- Vector-matrix ----------
599 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
600#if(CXSC_INDEX_CHECK)
601 ;
602#else
603 noexcept;
604#endif
605 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
606#if(CXSC_INDEX_CHECK)
607 ;
608#else
609 noexcept;
610#endif
611 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
612#if(CXSC_INDEX_CHECK)
613 ;
614#else
615 noexcept;
616#endif
617 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
618#if(CXSC_INDEX_CHECK)
619 ;
620#else
621 noexcept;
622#endif
623
624 // civector ---------------------
625template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
626#if(CXSC_INDEX_CHECK)
627 ;
628#else
629 noexcept;
630#endif
631template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
632#if(CXSC_INDEX_CHECK)
633 ;
634#else
635 noexcept;
636#endif
637 template <class V,class E> friend E _vim(const V &rv) noexcept;
638 template <class V,class E> friend E _vre(const V &rv) noexcept;
639
640 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
641#if(CXSC_INDEX_CHECK)
642 ;
643#else
644 noexcept;
645#endif
646 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
647#if(CXSC_INDEX_CHECK)
648 ;
649#else
650 noexcept;
651#endif
652template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
653#if(CXSC_INDEX_CHECK)
654;
655#else
656 noexcept;
657#endif
658template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
659#if(CXSC_INDEX_CHECK)
660;
661#else
662 noexcept;
663#endif
664template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
665template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
666
667 // vector-scalar
668 // vector-vector
669 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
670#if(CXSC_INDEX_CHECK)
671 ;
672#else
673 noexcept;
674#endif
675
676 // vector-matrix
677 // l_real
678 //--l_real -------- vector-scalar ------------
679 //--l_real--------- Vector-vector---------
680
681 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
682#if(CXSC_INDEX_CHECK)
683 ;
684#else
685 noexcept;
686#endif
687 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
688#if(CXSC_INDEX_CHECK)
689 ;
690#else
691 noexcept;
692#endif
693
694 //-- l_real -------- Vector-matrix ----------
695 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
696#if(CXSC_INDEX_CHECK)
697 ;
698#else
699 noexcept;
700#endif
701 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
702#if(CXSC_INDEX_CHECK)
703 ;
704#else
705 noexcept;
706#endif
707 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
708#if(CXSC_INDEX_CHECK)
709 ;
710#else
711 noexcept;
712#endif
713 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
714#if(CXSC_INDEX_CHECK)
715 ;
716#else
717 noexcept;
718#endif
719
720 // l_ivector ---------------------
721 // vector-scalar
722 // vector-vector
723 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
724#if(CXSC_INDEX_CHECK)
725 ;
726#else
727 noexcept;
728#endif
729 // vector-matrix
730
731#endif
732
733 //------ Konstruktoren ----------------------------------------------------
735 INLINE ivector () noexcept;
737 explicit INLINE ivector(const int &i) noexcept;
738#ifdef OLD_CXSC
740 explicit INLINE ivector(const class index &i) noexcept; // for backwards compatibility
741#endif
743 explicit INLINE ivector(const int &i1,const int &i2)
744#if(CXSC_INDEX_CHECK)
745;
746#else
747 noexcept;
748#endif
750 INLINE ivector(const imatrix_subv &) noexcept;
752 explicit INLINE ivector(const interval &) noexcept;
754// explicit INLINE ivector(const imatrix &)
755 explicit ivector(const imatrix &)
756#if(CXSC_INDEX_CHECK)
757;
758#else
759 noexcept;
760#endif
762 explicit INLINE ivector(const imatrix_slice &sl)
763#if(CXSC_INDEX_CHECK)
764;
765#else
766 noexcept;
767#endif
769 INLINE ivector(const ivector_slice &rs) noexcept;
771 INLINE ivector(const ivector &v) noexcept;
773 INLINE ivector(const sivector &rs);
775 INLINE ivector(const sivector_slice &rs);
776
777 // Real
779 explicit INLINE ivector(const real &) noexcept;
781 explicit INLINE ivector(const rvector_slice &rs) noexcept;
783 explicit INLINE ivector(const srvector &rs);
785 explicit INLINE ivector(const srvector_slice &rs);
786
788 explicit INLINE ivector(const rvector &v) noexcept;
790 explicit INLINE ivector(const rmatrix &)
791#if(CXSC_INDEX_CHECK)
792;
793#else
794 noexcept;
795#endif
797 explicit INLINE ivector(const rmatrix_slice &sl)
798#if(CXSC_INDEX_CHECK)
799;
800#else
801 noexcept;
802#endif
804// explicit INLINE ivector(const rmatrix_subv &) noexcept;
805 explicit ivector(const rmatrix_subv &) noexcept;
806
807 // Interval
809 INLINE ivector &operator =(const ivector &rv) noexcept;
811 INLINE ivector &operator =(const ivector_slice &sl) noexcept;
813 INLINE ivector &operator =(const sivector &rv);
815 INLINE ivector &operator =(const sivector_slice &sl);
817 INLINE ivector &operator =(const srvector &rv);
819 INLINE ivector &operator =(const srvector_slice &sl);
821 INLINE ivector &operator =(const interval &r) noexcept;
823 INLINE ivector &operator =(const imatrix &m)
824#if(CXSC_INDEX_CHECK)
825;
826#else
827 noexcept;
828#endif
830 INLINE ivector &operator =(const imatrix_slice &)
831#if(CXSC_INDEX_CHECK)
832;
833#else
834 noexcept;
835#endif
837 INLINE ivector &operator =(const imatrix_subv &) noexcept;
838 // Real
840 INLINE ivector &operator =(const rvector &rv) noexcept;
842 INLINE ivector &operator =(const rvector_slice &sl) noexcept;
844 INLINE ivector &operator =(const real &r) noexcept;
846 INLINE ivector &operator =(const rmatrix &m)
847#if(CXSC_INDEX_CHECK)
848;
849#else
850 noexcept;
851#endif
853 INLINE ivector &operator =(const rmatrix_slice &)
854#if(CXSC_INDEX_CHECK)
855;
856#else
857 noexcept;
858#endif
860 INLINE ivector &operator =(const rmatrix_subv &) noexcept;
861
863 INLINE ivector &operator+=(const srvector&);
865 INLINE ivector &operator+=(const sivector&);
867 INLINE ivector &operator+=(const srvector_slice&);
869 INLINE ivector &operator+=(const sivector_slice&);
871 INLINE ivector &operator-=(const srvector&);
873 INLINE ivector &operator-=(const sivector&);
875 INLINE ivector &operator-=(const srvector_slice&);
877 INLINE ivector &operator-=(const sivector_slice&);
879 INLINE ivector &operator|=(const srvector&);
881 INLINE ivector &operator|=(const sivector&);
883 INLINE ivector &operator|=(const srvector_slice&);
885 INLINE ivector &operator|=(const sivector_slice&);
887 INLINE ivector &operator&=(const sivector&);
889 INLINE ivector &operator&=(const sivector_slice&);
890
892 INLINE ivector operator()(const intvector& p);
894 INLINE ivector operator()(const intmatrix& P);
895
896 //--------- Destruktor ----------------------------------------------------
897 INLINE ~ivector() { delete [] dat; }
898
899 //------ Standardfunktionen -----------------------------------------------
900
901 friend INLINE interval::interval(const ivector &)
902#if(CXSC_INDEX_CHECK)
903;
904#else
905 noexcept;
906#endif
908 friend INLINE int Lb(const ivector &rv) noexcept { return rv.l; }
910 friend INLINE int Ub(const ivector &rv) noexcept { return rv.u; }
912 friend INLINE int VecLen(const ivector &rv) noexcept { return rv.size; }
914 friend INLINE ivector &SetLb(ivector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv; }
916 friend INLINE ivector &SetUb(ivector &rv, const int &u) noexcept { rv.u=u; rv.l=u-rv.size+1; return rv; }
918 INLINE interval & operator [](const int &i) const
919#if(CXSC_INDEX_CHECK)
920;
921#else
922 noexcept;
923#endif
924
926 INLINE interval & operator [](const int &i)
927#if(CXSC_INDEX_CHECK)
928;
929#else
930 noexcept;
931#endif
932
934 INLINE ivector & operator ()() noexcept { return *this; }
936 INLINE ivector_slice operator ()(const int &i)
937#if(CXSC_INDEX_CHECK)
938;
939#else
940 noexcept;
941#endif
943 INLINE ivector_slice operator ()(const int &i1,const int &i2)
944#if(CXSC_INDEX_CHECK)
945;
946#else
947 noexcept;
948#endif
949
950 INLINE operator void*() noexcept;
951//#else
952//#endif
953};
954
955
957
963{
964 friend class ivector;
965 friend class imatrix;
966 friend class civector;
967 friend class cimatrix;
968 friend class l_ivector;
969 friend class l_imatrix;
970 private:
971 interval *dat;
972 int l,u,size;
973 int start,end;
974
975 public:
976//#if(CXSC_INDEX_CHECK)
977#ifdef _CXSC_FRIEND_TPL
978//------------------------- Templates -------------------------------------------
979// Interval / Interval
980
981 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
982#if(CXSC_INDEX_CHECK)
983 ;
984#else
985 noexcept;
986#endif
987 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
988 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
989#if(CXSC_INDEX_CHECK)
990 ;
991#else
992 noexcept;
993#endif
994 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
995 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
996#if(CXSC_INDEX_CHECK)
997 ;
998#else
999 noexcept;
1000#endif
1001 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
1002#if(CXSC_INDEX_CHECK)
1003 ;
1004#else
1005 noexcept;
1006#endif
1007 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1008#if(CXSC_INDEX_CHECK)
1009 ;
1010#else
1011 noexcept;
1012#endif
1013 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1014#if(CXSC_INDEX_CHECK)
1015 ;
1016#else
1017 noexcept;
1018#endif
1019 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
1020#if(CXSC_INDEX_CHECK)
1021 ;
1022#else
1023 noexcept;
1024#endif
1025 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
1026#if(CXSC_INDEX_CHECK)
1027 ;
1028#else
1029 noexcept;
1030#endif
1031 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1032#if(CXSC_INDEX_CHECK)
1033 ;
1034#else
1035 noexcept;
1036#endif
1037 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1038#if(CXSC_INDEX_CHECK)
1039 ;
1040#else
1041 noexcept;
1042#endif
1043 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) noexcept;
1044 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) noexcept;
1045 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) noexcept;
1046 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) noexcept;
1047
1048 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1049#if(CXSC_INDEX_CHECK)
1050 ;
1051#else
1052 noexcept;
1053#endif
1054 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1055#if(CXSC_INDEX_CHECK)
1056 ;
1057#else
1058 noexcept;
1059#endif
1060
1061 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
1062 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
1063
1064 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
1065#if(CXSC_INDEX_CHECK)
1066 ;
1067#else
1068 noexcept;
1069#endif
1070 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
1071 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
1072 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1073#if(CXSC_INDEX_CHECK)
1074 ;
1075#else
1076 noexcept;
1077#endif
1078 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1079#if(CXSC_INDEX_CHECK)
1080 ;
1081#else
1082 noexcept;
1083#endif
1084 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1085#if(CXSC_INDEX_CHECK)
1086 ;
1087#else
1088 noexcept;
1089#endif
1090 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1091#if(CXSC_INDEX_CHECK)
1092 ;
1093#else
1094 noexcept;
1095#endif
1096 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1097#if(CXSC_INDEX_CHECK)
1098 ;
1099#else
1100 noexcept;
1101#endif
1102 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1103#if(CXSC_INDEX_CHECK)
1104 ;
1105#else
1106 noexcept;
1107#endif
1108 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1109#if(CXSC_INDEX_CHECK)
1110 ;
1111#else
1112 noexcept;
1113#endif
1114 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1115#if(CXSC_INDEX_CHECK)
1116 ;
1117#else
1118 noexcept;
1119#endif
1120 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1121#if(CXSC_INDEX_CHECK)
1122 ;
1123#else
1124 noexcept;
1125#endif
1126 template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
1127 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1128#if(CXSC_INDEX_CHECK)
1129 ;
1130#else
1131 noexcept;
1132#endif
1133 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1134#if(CXSC_INDEX_CHECK)
1135 ;
1136#else
1137 noexcept;
1138#endif
1139 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1140#if(CXSC_INDEX_CHECK)
1141 ;
1142#else
1143 noexcept;
1144#endif
1145 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1146#if(CXSC_INDEX_CHECK)
1147 ;
1148#else
1149 noexcept;
1150#endif
1151 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1152#if(CXSC_INDEX_CHECK)
1153 ;
1154#else
1155 noexcept;
1156#endif
1157 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1158#if(CXSC_INDEX_CHECK)
1159 ;
1160#else
1161 noexcept;
1162#endif
1163 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1164#if(CXSC_INDEX_CHECK)
1165 ;
1166#else
1167 noexcept;
1168#endif
1169 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1170#if(CXSC_INDEX_CHECK)
1171 ;
1172#else
1173 noexcept;
1174#endif
1175 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1176#if(CXSC_INDEX_CHECK)
1177 ;
1178#else
1179 noexcept;
1180#endif
1181 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1182#if(CXSC_INDEX_CHECK)
1183 ;
1184#else
1185 noexcept;
1186#endif
1187 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1188#if(CXSC_INDEX_CHECK)
1189 ;
1190#else
1191 noexcept;
1192#endif
1193 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1194#if(CXSC_INDEX_CHECK)
1195 ;
1196#else
1197 noexcept;
1198#endif
1199 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
1200#if(CXSC_INDEX_CHECK)
1201 ;
1202#else
1203 noexcept;
1204#endif
1205
1206 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
1207 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
1208 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
1209 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
1210 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
1211 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
1212 template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
1213 template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
1214 template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
1215 template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
1216 template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
1217 template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
1218#if(CXSC_INDEX_CHECK)
1219 ;
1220#else
1221 noexcept;
1222#endif
1223 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
1224 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
1225 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
1226 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
1227 template <class VS> friend bool _vsnot(const VS &sl) noexcept;
1228 template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
1229 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
1230 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
1231
1232 // Interval / Real
1233 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1234#if(CXSC_INDEX_CHECK)
1235 ;
1236#else
1237 noexcept;
1238#endif
1239
1240 // complex
1241 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1242#if(CXSC_INDEX_CHECK)
1243 ;
1244#else
1245 noexcept;
1246#endif
1247 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
1248#if(CXSC_INDEX_CHECK)
1249 ;
1250#else
1251 noexcept;
1252#endif
1253 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
1254#if(CXSC_INDEX_CHECK)
1255 ;
1256#else
1257 noexcept;
1258#endif
1259 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1260#if(CXSC_INDEX_CHECK)
1261 ;
1262#else
1263 noexcept;
1264#endif
1265 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1266#if(CXSC_INDEX_CHECK)
1267 ;
1268#else
1269 noexcept;
1270#endif
1271
1272 // cinterval-- vector-scalar
1273 // cinterval -- vector-vector
1274template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1275#if(CXSC_INDEX_CHECK)
1276 ;
1277#else
1278 noexcept;
1279#endif
1280
1281 // cinterval -- vector-matrix
1282 // l_real
1283
1284 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1285#if(CXSC_INDEX_CHECK)
1286 ;
1287#else
1288 noexcept;
1289#endif
1290
1291 // l_interval ----------
1292 // l_interval-- vector-scalar
1293 // l_interval -- vector-vector
1294template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
1295#if(CXSC_INDEX_CHECK)
1296 ;
1297#else
1298 noexcept;
1299#endif
1300
1301
1302#endif
1303
1304 //--------------------- Konstruktoren -----------------------------------
1306 explicit INLINE ivector_slice(ivector &a, const int &lb, const int &ub) noexcept:dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
1308 explicit INLINE ivector_slice(ivector_slice &a, const int &lb, const int &ub) noexcept:dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
1309 public:
1311 INLINE ivector_slice(const ivector_slice &a) noexcept:dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1312 public:
1313 // Interval
1315 INLINE ivector_slice & operator =(const sivector &sl);
1317 INLINE ivector_slice & operator =(const sivector_slice &sl);
1319 INLINE ivector_slice & operator =(const srvector &sl);
1321 INLINE ivector_slice & operator =(const srvector_slice &sl);
1322
1324 INLINE ivector_slice & operator =(const ivector_slice &sl)
1325#if(CXSC_INDEX_CHECK)
1326;
1327#else
1328 noexcept;
1329#endif
1331 INLINE ivector_slice & operator =(const ivector &rv)
1332#if(CXSC_INDEX_CHECK)
1333;
1334#else
1335 noexcept;
1336#endif
1338 INLINE ivector_slice & operator =(const interval &r) noexcept;
1340 INLINE ivector_slice & operator =(const imatrix &m)
1341#if(CXSC_INDEX_CHECK)
1342;
1343#else
1344 noexcept;
1345#endif
1347 INLINE ivector_slice & operator =(const imatrix_slice &m)
1348#if(CXSC_INDEX_CHECK)
1349;
1350#else
1351 noexcept;
1352#endif
1354 INLINE ivector_slice &operator =(const imatrix_subv &) noexcept;
1355 // Real
1357 INLINE ivector_slice & operator =(const rvector_slice &sl)
1358#if(CXSC_INDEX_CHECK)
1359;
1360#else
1361 noexcept;
1362#endif
1364 INLINE ivector_slice & operator =(const rvector &rv)
1365#if(CXSC_INDEX_CHECK)
1366;
1367#else
1368 noexcept;
1369#endif
1371 INLINE ivector_slice & operator =(const real &r) noexcept;
1373 INLINE ivector_slice & operator =(const rmatrix &m)
1374#if(CXSC_INDEX_CHECK)
1375;
1376#else
1377 noexcept;
1378#endif
1380 INLINE ivector_slice & operator =(const rmatrix_slice &m)
1381#if(CXSC_INDEX_CHECK)
1382;
1383#else
1384 noexcept;
1385#endif
1387 INLINE ivector_slice &operator =(const rmatrix_subv &mv) noexcept;
1388
1389 //--------------------- Standardfunktionen ------------------------------
1390
1391 friend INLINE interval::interval(const ivector_slice &sl)
1392#if(CXSC_INDEX_CHECK)
1393;
1394#else
1395 noexcept;
1396#endif
1398 friend INLINE int Lb(const ivector_slice &sl) noexcept { return sl.start; }
1400 friend INLINE int Ub(const ivector_slice &sl) noexcept { return sl.end; }
1402 friend INLINE int VecLen(const ivector_slice &sl) noexcept { return sl.end-sl.start+1; }
1404 INLINE interval & operator [](const int &i) const
1405#if(CXSC_INDEX_CHECK)
1406;
1407#else
1408 noexcept;
1409#endif
1410
1412 INLINE interval & operator [](const int &i)
1413#if(CXSC_INDEX_CHECK)
1414;
1415#else
1416 noexcept;
1417#endif
1418
1420 INLINE ivector_slice & operator ()() noexcept { return *this; }
1422 INLINE ivector_slice operator ()(const int &i)
1423#if(CXSC_INDEX_CHECK)
1424;
1425#else
1426 noexcept;
1427#endif
1429 INLINE ivector_slice operator ()(const int &i1,const int &i2)
1430#if(CXSC_INDEX_CHECK)
1431;
1432#else
1433 noexcept;
1434#endif
1435
1437 INLINE ivector_slice &operator /=(const interval &r) noexcept;
1439 INLINE ivector_slice &operator /=(const real &r) noexcept;
1441 INLINE ivector_slice &operator *=(const interval &r) noexcept;
1443 INLINE ivector_slice &operator *=(const imatrix &m)
1444#if(CXSC_INDEX_CHECK)
1445;
1446#else
1447 noexcept;
1448#endif
1450 INLINE ivector_slice &operator *=(const rmatrix &m)
1451#if(CXSC_INDEX_CHECK)
1452;
1453#else
1454 noexcept;
1455#endif
1457 INLINE ivector_slice &operator *=(const real &r) noexcept;
1459 INLINE ivector_slice &operator +=(const ivector &rv)
1460#if(CXSC_INDEX_CHECK)
1461;
1462#else
1463 noexcept;
1464#endif
1466 INLINE ivector_slice &operator +=(const ivector_slice &sl2)
1467#if(CXSC_INDEX_CHECK)
1468;
1469#else
1470 noexcept;
1471#endif
1473 INLINE ivector_slice &operator -=(const ivector &rv)
1474#if(CXSC_INDEX_CHECK)
1475;
1476#else
1477 noexcept;
1478#endif
1480 INLINE ivector_slice &operator -=(const ivector_slice &sl2)
1481#if(CXSC_INDEX_CHECK)
1482;
1483#else
1484 noexcept;
1485#endif
1487 INLINE ivector_slice &operator |=(const ivector &rv)
1488#if(CXSC_INDEX_CHECK)
1489;
1490#else
1491 noexcept;
1492#endif
1494 INLINE ivector_slice &operator |=(const ivector_slice &sl2)
1495#if(CXSC_INDEX_CHECK)
1496;
1497#else
1498 noexcept;
1499#endif
1501 INLINE ivector_slice &operator &=(const ivector &rv)
1502#if(CXSC_INDEX_CHECK)
1503;
1504#else
1505 noexcept;
1506#endif
1508 INLINE ivector_slice &operator &=(const ivector_slice &sl2)
1509#if(CXSC_INDEX_CHECK)
1510;
1511#else
1512 noexcept;
1513#endif
1514
1516 INLINE ivector_slice &operator +=(const rvector &rv)
1517#if(CXSC_INDEX_CHECK)
1518;
1519#else
1520 noexcept;
1521#endif
1523 INLINE ivector_slice &operator +=(const rvector_slice &sl2)
1524#if(CXSC_INDEX_CHECK)
1525;
1526#else
1527 noexcept;
1528#endif
1530 INLINE ivector_slice &operator -=(const rvector &rv)
1531#if(CXSC_INDEX_CHECK)
1532;
1533#else
1534 noexcept;
1535#endif
1537 INLINE ivector_slice &operator -=(const rvector_slice &sl2)
1538#if(CXSC_INDEX_CHECK)
1539;
1540#else
1541 noexcept;
1542#endif
1544 INLINE ivector_slice &operator |=(const rvector &rv)
1545#if(CXSC_INDEX_CHECK)
1546;
1547#else
1548 noexcept;
1549#endif
1551 INLINE ivector_slice &operator |=(const rvector_slice &sl2)
1552#if(CXSC_INDEX_CHECK)
1553;
1554#else
1555 noexcept;
1556#endif
1558 INLINE ivector_slice &operator &=(const rvector &rv)
1559#if(CXSC_INDEX_CHECK)
1560;
1561#else
1562 noexcept;
1563#endif
1565 INLINE ivector_slice &operator &=(const rvector_slice &sl2)
1566#if(CXSC_INDEX_CHECK)
1567;
1568#else
1569 noexcept;
1570#endif
1571 INLINE operator void*() noexcept;
1572//#else
1573//#endif
1574
1576 INLINE ivector_slice &operator+=(const srvector&);
1578 INLINE ivector_slice &operator+=(const sivector&);
1580 INLINE ivector_slice &operator+=(const srvector_slice&);
1582 INLINE ivector_slice &operator+=(const sivector_slice&);
1584 INLINE ivector_slice &operator-=(const srvector&);
1586 INLINE ivector_slice &operator-=(const sivector&);
1588 INLINE ivector_slice &operator-=(const srvector_slice&);
1590 INLINE ivector_slice &operator-=(const sivector_slice&);
1592 INLINE ivector_slice &operator|=(const srvector&);
1594 INLINE ivector_slice &operator|=(const sivector&);
1596 INLINE ivector_slice &operator|=(const srvector_slice&);
1598 INLINE ivector_slice &operator|=(const sivector_slice&);
1600 INLINE ivector_slice &operator&=(const sivector&);
1602 INLINE ivector_slice &operator&=(const sivector_slice&);
1603
1604};
1605
1606//=======================================================================
1607//======================== Vector Functions =============================
1608
1610 INLINE ivector _ivector(const interval &r) noexcept;
1611// INLINE ivector _ivector(const imatrix &m);
1612// INLINE ivector _ivector(const imatrix_slice &sl);
1614 INLINE ivector _ivector(const real &r) noexcept;
1616 INLINE ivector _ivector(const rvector_slice &rs) noexcept;
1618 INLINE ivector _ivector(const rvector &rs) noexcept;
1619// INLINE ivector _ivector(const rmatrix &m);
1620// INLINE ivector _ivector(const rmatrix_slice &sl);
1622 INLINE ivector _ivector(const rmatrix_subv &rs) noexcept;
1623
1625 INLINE ivector &SetInf(ivector &iv,const rvector &rv)
1626#if(CXSC_INDEX_CHECK)
1627;
1628#else
1629 noexcept;
1630#endif
1632 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv)
1633#if(CXSC_INDEX_CHECK)
1634;
1635#else
1636 noexcept;
1637#endif
1639 INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv)
1640#if(CXSC_INDEX_CHECK)
1641;
1642#else
1643 noexcept;
1644#endif
1646 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv)
1647#if(CXSC_INDEX_CHECK)
1648;
1649#else
1650 noexcept;
1651#endif
1653 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv)
1654#if(CXSC_INDEX_CHECK)
1655;
1656#else
1657 noexcept;
1658#endif
1660 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv)
1661#if(CXSC_INDEX_CHECK)
1662;
1663#else
1664 noexcept;
1665#endif
1667 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv)
1668#if(CXSC_INDEX_CHECK)
1669;
1670#else
1671 noexcept;
1672#endif
1674 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv)
1675#if(CXSC_INDEX_CHECK)
1676;
1677#else
1678 noexcept;
1679#endif
1680
1682 INLINE ivector &SetSup(ivector &iv,const rvector &rv)
1683#if(CXSC_INDEX_CHECK)
1684;
1685#else
1686 noexcept;
1687#endif
1689 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv)
1690#if(CXSC_INDEX_CHECK)
1691;
1692#else
1693 noexcept;
1694#endif
1696 INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv)
1697#if(CXSC_INDEX_CHECK)
1698;
1699#else
1700 noexcept;
1701#endif
1703 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv)
1704#if(CXSC_INDEX_CHECK)
1705;
1706#else
1707 noexcept;
1708#endif
1710 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv)
1711#if(CXSC_INDEX_CHECK)
1712;
1713#else
1714 noexcept;
1715#endif
1717 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv)
1718#if(CXSC_INDEX_CHECK)
1719;
1720#else
1721 noexcept;
1722#endif
1724 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv)
1725#if(CXSC_INDEX_CHECK)
1726;
1727#else
1728 noexcept;
1729#endif
1731 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv)
1732#if(CXSC_INDEX_CHECK)
1733;
1734#else
1735 noexcept;
1736#endif
1737
1739 INLINE ivector &SetSup(ivector &iv,const real &r) noexcept;
1741 INLINE ivector &SetInf(ivector &iv,const real &r) noexcept;
1743 INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) noexcept;
1745 INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) noexcept;
1747 INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) noexcept;
1749 INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) noexcept;
1751 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) noexcept;
1753 INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) noexcept;
1754
1756 INLINE void Resize(ivector &rv) noexcept;
1758 INLINE void Resize(ivector &rv, const int &len)
1759#if(CXSC_INDEX_CHECK)
1760;
1761#else
1762 noexcept;
1763#endif
1765 INLINE void Resize(ivector &rv, const int &lb, const int &ub)
1766#if(CXSC_INDEX_CHECK)
1767;
1768#else
1769 noexcept;
1770#endif
1771
1773 INLINE ivector abs(const ivector &rv) noexcept;
1775 INLINE ivector abs(const ivector_slice &sl) noexcept;
1777 INLINE rvector absmin(const ivector &rv) noexcept;
1779 INLINE rvector absmax(const ivector_slice &sl) noexcept;
1781 INLINE rvector absmin(const ivector &rv) noexcept;
1783 INLINE rvector absmax(const ivector_slice &sl) noexcept;
1785 INLINE rvector diam(const ivector &v) noexcept;
1787 INLINE rvector diam(const ivector_slice &v) noexcept;
1789 INLINE rvector mid(const ivector &v) noexcept;
1791 INLINE rvector mid(const ivector_slice &v) noexcept;
1793 INLINE rvector Inf(const ivector &v) noexcept;
1795 INLINE rvector Inf(const ivector_slice &v) noexcept;
1797 INLINE rvector Sup(const ivector &v) noexcept;
1799 INLINE rvector Sup(const ivector_slice &v) noexcept;
1801 INLINE bool operator !(const ivector &rv) noexcept;
1803 INLINE bool operator !(const ivector_slice &sl) noexcept;
1804
1805//======================= Vector / Scalar ===============================
1806
1807//----------------------------- Interval ---------------------------
1808
1810 INLINE ivector operator *(const ivector &rv, const interval &s) noexcept;
1812 INLINE ivector operator *(const ivector_slice &sl, const interval &s) noexcept;
1814 INLINE ivector operator *(const interval &s, const ivector &rv) noexcept;
1816 INLINE ivector operator *(const interval &s, const ivector_slice &sl) noexcept;
1818 INLINE ivector &operator *=(ivector &rv,const interval &r) noexcept;
1819
1821 INLINE ivector operator /(const ivector &rv, const interval &s) noexcept;
1823 INLINE ivector operator /(const ivector_slice &sl, const interval &s) noexcept;
1825 INLINE ivector &operator /=(ivector &rv,const interval &r) noexcept;
1826
1827//---------------------------- Real --------------------------------------
1828
1830 INLINE ivector operator *(const ivector &rv, const real &s) noexcept;
1832 INLINE ivector operator *(const ivector_slice &sl, const real &s) noexcept;
1834 INLINE ivector operator *(const real &s, const ivector &rv) noexcept;
1836 INLINE ivector operator *(const real &s, const ivector_slice &sl) noexcept;
1838 INLINE ivector &operator *=(ivector &rv,const real &r) noexcept;
1839
1841 INLINE ivector operator /(const ivector &rv, const real &s) noexcept;
1843 INLINE ivector operator /(const ivector_slice &sl, const real &s) noexcept;
1845 INLINE ivector &operator /=(ivector &rv,const real &r) noexcept;
1846
1848 INLINE ivector operator *(const rvector &rv, const interval &s) noexcept;
1850 INLINE ivector operator *(const rvector_slice &sl, const interval &s) noexcept;
1852 INLINE ivector operator *(const interval &s, const rvector &rv) noexcept;
1854 INLINE ivector operator *(const interval &s, const rvector_slice &sl) noexcept;
1855
1857 INLINE ivector operator /(const rvector &rv, const interval &s) noexcept;
1859 INLINE ivector operator /(const rvector_slice &sl, const interval &s) noexcept;
1860
1861//======================= Vector / Vector ===============================
1862
1863
1865 INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) noexcept;
1867 INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) noexcept;
1869 INLINE std::istream &operator >>(std::istream &s, ivector &rv) noexcept;
1871 INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) noexcept;
1872
1873//----------------------- Interval / Interval ---------------------------
1874
1876 void accumulate(idotprecision &dp, const ivector &);
1877
1879 void accumulate(idotprecision &dp, const rvector &);
1880
1882 void accumulate(idotprecision &dp, const ivector & rv1, const ivector &rv2)
1883#if(CXSC_INDEX_CHECK)
1884;
1885#else
1886 noexcept;
1887#endif
1889 void accumulate(idotprecision &dp, const ivector_slice & sl, const ivector &rv)
1890#if(CXSC_INDEX_CHECK)
1891;
1892#else
1893 noexcept;
1894#endif
1896 void accumulate(idotprecision &dp, const ivector &rv, const ivector_slice &sl)
1897#if(CXSC_INDEX_CHECK)
1898;
1899#else
1900 noexcept;
1901#endif
1903 void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1904#if(CXSC_INDEX_CHECK)
1905;
1906#else
1907 noexcept;
1908#endif
1910 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1911#if(CXSC_INDEX_CHECK)
1912;
1913#else
1914 noexcept;
1915#endif
1917 void accumulate(idotprecision &dp, const ivector_slice & rv1, const imatrix_subv &rv2)
1918#if(CXSC_INDEX_CHECK)
1919;
1920#else
1921 noexcept;
1922#endif
1924 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &rv2)
1925#if(CXSC_INDEX_CHECK)
1926;
1927#else
1928 noexcept;
1929#endif
1931 void accumulate(idotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1932#if(CXSC_INDEX_CHECK)
1933;
1934#else
1935 noexcept;
1936#endif
1938 void accumulate(cidotprecision &dp, const ivector & rv1, const ivector &rv2)
1939#if(CXSC_INDEX_CHECK)
1940;
1941#else
1942 noexcept;
1943#endif
1945 void accumulate(cidotprecision &dp, const ivector_slice & sl, const ivector &rv)
1946#if(CXSC_INDEX_CHECK)
1947;
1948#else
1949 noexcept;
1950#endif
1952 void accumulate(cidotprecision &dp, const ivector &rv, const ivector_slice &sl)
1953#if(CXSC_INDEX_CHECK)
1954;
1955#else
1956 noexcept;
1957#endif
1959 void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1960#if(CXSC_INDEX_CHECK)
1961;
1962#else
1963 noexcept;
1964#endif
1966 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1967#if(CXSC_INDEX_CHECK)
1968;
1969#else
1970 noexcept;
1971#endif
1973 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1974#if(CXSC_INDEX_CHECK)
1975;
1976#else
1977 noexcept;
1978#endif
1979
1981 INLINE interval operator *(const ivector & rv1, const ivector &rv2)
1982#if(CXSC_INDEX_CHECK)
1983;
1984#else
1985 noexcept;
1986#endif
1988 INLINE interval operator *(const ivector_slice &sl, const ivector &rv)
1989#if(CXSC_INDEX_CHECK)
1990;
1991#else
1992 noexcept;
1993#endif
1995 INLINE interval operator *(const ivector &rv, const ivector_slice &sl)
1996#if(CXSC_INDEX_CHECK)
1997;
1998#else
1999 noexcept;
2000#endif
2002 INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2)
2003#if(CXSC_INDEX_CHECK)
2004;
2005#else
2006 noexcept;
2007#endif
2008
2010 INLINE const ivector &operator +(const ivector &rv) noexcept;
2012 INLINE ivector operator +(const ivector_slice &sl) noexcept;
2013
2015 INLINE ivector operator +(const ivector &rv1, const ivector &rv2)
2016#if(CXSC_INDEX_CHECK)
2017;
2018#else
2019 noexcept;
2020#endif
2022 INLINE ivector operator +(const ivector &rv, const ivector_slice &sl)
2023#if(CXSC_INDEX_CHECK)
2024;
2025#else
2026 noexcept;
2027#endif
2029 INLINE ivector operator +(const ivector_slice &sl, const ivector &rv)
2030#if(CXSC_INDEX_CHECK)
2031;
2032#else
2033 noexcept;
2034#endif
2036 INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2)
2037#if(CXSC_INDEX_CHECK)
2038;
2039#else
2040 noexcept;
2041#endif
2043 INLINE ivector & operator +=(ivector &rv1, const ivector &rv2)
2044#if(CXSC_INDEX_CHECK)
2045;
2046#else
2047 noexcept;
2048#endif
2050 INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl)
2051#if(CXSC_INDEX_CHECK)
2052;
2053#else
2054 noexcept;
2055#endif
2056
2058 INLINE ivector operator -(const ivector &rv) noexcept;
2060 INLINE ivector operator -(const ivector_slice &sl) noexcept;
2062 INLINE ivector operator -(const ivector &rv1, const ivector &rv2)
2063#if(CXSC_INDEX_CHECK)
2064;
2065#else
2066 noexcept;
2067#endif
2069 INLINE ivector operator -(const ivector &rv, const ivector_slice &sl)
2070#if(CXSC_INDEX_CHECK)
2071;
2072#else
2073 noexcept;
2074#endif
2076 INLINE ivector operator -(const ivector_slice &sl, const ivector &rv)
2077#if(CXSC_INDEX_CHECK)
2078;
2079#else
2080 noexcept;
2081#endif
2083 INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2)
2084#if(CXSC_INDEX_CHECK)
2085;
2086#else
2087 noexcept;
2088#endif
2090 INLINE ivector & operator -=(ivector &rv1, const ivector &rv2)
2091#if(CXSC_INDEX_CHECK)
2092;
2093#else
2094 noexcept;
2095#endif
2097 INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl)
2098#if(CXSC_INDEX_CHECK)
2099;
2100#else
2101 noexcept;
2102#endif
2103
2105 INLINE ivector operator |(const ivector &rv1, const ivector &rv2)
2106#if(CXSC_INDEX_CHECK)
2107;
2108#else
2109 noexcept;
2110#endif
2112 INLINE ivector operator |(const ivector &rv, const ivector_slice &sl)
2113#if(CXSC_INDEX_CHECK)
2114;
2115#else
2116 noexcept;
2117#endif
2119 INLINE ivector operator |(const ivector_slice &sl, const ivector &rv)
2120#if(CXSC_INDEX_CHECK)
2121;
2122#else
2123 noexcept;
2124#endif
2126 INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2)
2127#if(CXSC_INDEX_CHECK)
2128;
2129#else
2130 noexcept;
2131#endif
2133 INLINE ivector & operator |=(ivector &rv1, const ivector &rv2)
2134#if(CXSC_INDEX_CHECK)
2135;
2136#else
2137 noexcept;
2138#endif
2140 INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl)
2141#if(CXSC_INDEX_CHECK)
2142;
2143#else
2144 noexcept;
2145#endif
2146
2148 INLINE ivector operator &(const ivector &rv1, const ivector &rv2)
2149#if(CXSC_INDEX_CHECK)
2150;
2151#else
2152 noexcept;
2153#endif
2155 INLINE ivector operator &(const ivector &rv, const ivector_slice &sl)
2156#if(CXSC_INDEX_CHECK)
2157;
2158#else
2159 noexcept;
2160#endif
2162 INLINE ivector operator &(const ivector_slice &sl, const ivector &rv)
2163#if(CXSC_INDEX_CHECK)
2164;
2165#else
2166 noexcept;
2167#endif
2169 INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2)
2170#if(CXSC_INDEX_CHECK)
2171;
2172#else
2173 noexcept;
2174#endif
2176 INLINE ivector & operator &=(ivector &rv1, const ivector &rv2)
2177#if(CXSC_INDEX_CHECK)
2178;
2179#else
2180 noexcept;
2181#endif
2183 INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl)
2184#if(CXSC_INDEX_CHECK)
2185;
2186#else
2187 noexcept;
2188#endif
2189
2191 INLINE bool operator ==(const ivector &rv1, const ivector &rv2) noexcept;
2193 INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2195 INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) noexcept;
2197 INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) noexcept;
2199 INLINE bool operator !=(const ivector &rv1, const ivector &rv2) noexcept;
2201 INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2203 INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) noexcept;
2205 INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) noexcept;
2207 INLINE bool operator <(const ivector &rv1, const ivector &rv2) noexcept;
2209 INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2211 INLINE bool operator < (const ivector_slice &sl, const ivector &rv) noexcept;
2213 INLINE bool operator < (const ivector &rv, const ivector_slice &sl) noexcept;
2215 INLINE bool operator <=(const ivector &rv1, const ivector &rv2) noexcept;
2217 INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2219 INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) noexcept;
2221 INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) noexcept;
2223 INLINE bool operator >(const ivector &rv1, const ivector &rv2) noexcept;
2225 INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2227 INLINE bool operator >(const ivector_slice &sl, const ivector &rv) noexcept;
2229 INLINE bool operator >(const ivector &rv, const ivector_slice &sl) noexcept;
2231 INLINE bool operator >=(const ivector &rv1, const ivector &rv2) noexcept;
2233 INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2235 INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) noexcept;
2237 INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) noexcept;
2238
2239//-------------------------------- Interval / Real --------------------------------
2240
2242 void accumulate(idotprecision &dp, const rvector & rv1, const ivector &rv2)
2243#if(CXSC_INDEX_CHECK)
2244;
2245#else
2246 noexcept;
2247#endif
2249 void accumulate(idotprecision &dp, const ivector & rv1, const rvector &rv2)
2250#if(CXSC_INDEX_CHECK)
2251;
2252#else
2253 noexcept;
2254#endif
2256 void accumulate(idotprecision &dp, const rvector_slice & sl, const ivector &rv)
2257#if(CXSC_INDEX_CHECK)
2258;
2259#else
2260 noexcept;
2261#endif
2263 void accumulate(idotprecision &dp,const ivector_slice &sl,const rvector &rv)
2264#if(CXSC_INDEX_CHECK)
2265;
2266#else
2267 noexcept;
2268#endif
2270 void accumulate(idotprecision &dp, const rvector &rv, const ivector_slice &sl)
2271#if(CXSC_INDEX_CHECK)
2272;
2273#else
2274 noexcept;
2275#endif
2277 void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2278#if(CXSC_INDEX_CHECK)
2279;
2280#else
2281 noexcept;
2282#endif
2284 void accumulate(idotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2285#if(CXSC_INDEX_CHECK)
2286;
2287#else
2288 noexcept;
2289#endif
2291 void accumulate(idotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2292#if(CXSC_INDEX_CHECK)
2293;
2294#else
2295 noexcept;
2296#endif
2298 void accumulate(idotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2299#if(CXSC_INDEX_CHECK)
2300;
2301#else
2302 noexcept;
2303#endif
2305 void accumulate(idotprecision &dp,const ivector &rv,const rvector_slice &sl)
2306#if(CXSC_INDEX_CHECK)
2307;
2308#else
2309 noexcept;
2310#endif
2312 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2313#if(CXSC_INDEX_CHECK)
2314;
2315#else
2316 noexcept;
2317#endif
2319 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2320#if(CXSC_INDEX_CHECK)
2321;
2322#else
2323 noexcept;
2324#endif
2326 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2327#if(CXSC_INDEX_CHECK)
2328;
2329#else
2330 noexcept;
2331#endif
2333 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2334#if(CXSC_INDEX_CHECK)
2335;
2336#else
2337 noexcept;
2338#endif
2340 void accumulate(idotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2341#if(CXSC_INDEX_CHECK)
2342;
2343#else
2344 noexcept;
2345#endif
2347 void accumulate(idotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2348#if(CXSC_INDEX_CHECK)
2349;
2350#else
2351 noexcept;
2352#endif
2354 void accumulate(cidotprecision &dp, const rvector & rv1, const ivector &rv2)
2355#if(CXSC_INDEX_CHECK)
2356;
2357#else
2358 noexcept;
2359#endif
2361 void accumulate(cidotprecision &dp, const ivector & rv1, const rvector &rv2)
2362#if(CXSC_INDEX_CHECK)
2363;
2364#else
2365 noexcept;
2366#endif
2368 void accumulate(cidotprecision &dp, const rvector_slice & sl, const ivector &rv)
2369#if(CXSC_INDEX_CHECK)
2370;
2371#else
2372 noexcept;
2373#endif
2375 void accumulate(cidotprecision &dp,const ivector_slice &sl,const rvector &rv)
2376#if(CXSC_INDEX_CHECK)
2377;
2378#else
2379 noexcept;
2380#endif
2382 void accumulate(cidotprecision &dp, const rvector &rv, const ivector_slice &sl)
2383#if(CXSC_INDEX_CHECK)
2384;
2385#else
2386 noexcept;
2387#endif
2389 void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2390#if(CXSC_INDEX_CHECK)
2391;
2392#else
2393 noexcept;
2394#endif
2396 void accumulate(cidotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2397#if(CXSC_INDEX_CHECK)
2398;
2399#else
2400 noexcept;
2401#endif
2403 void accumulate(cidotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2404#if(CXSC_INDEX_CHECK)
2405;
2406#else
2407 noexcept;
2408#endif
2410 void accumulate(cidotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2411#if(CXSC_INDEX_CHECK)
2412;
2413#else
2414 noexcept;
2415#endif
2417 void accumulate(cidotprecision &dp,const ivector &rv,const rvector_slice &sl)
2418#if(CXSC_INDEX_CHECK)
2419;
2420#else
2421 noexcept;
2422#endif
2424 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2425#if(CXSC_INDEX_CHECK)
2426;
2427#else
2428 noexcept;
2429#endif
2431 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2432#if(CXSC_INDEX_CHECK)
2433;
2434#else
2435 noexcept;
2436#endif
2438 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2439#if(CXSC_INDEX_CHECK)
2440;
2441#else
2442 noexcept;
2443#endif
2445 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2446#if(CXSC_INDEX_CHECK)
2447;
2448#else
2449 noexcept;
2450#endif
2452 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2453#if(CXSC_INDEX_CHECK)
2454;
2455#else
2456 noexcept;
2457#endif
2459 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2460#if(CXSC_INDEX_CHECK)
2461;
2462#else
2463 noexcept;
2464#endif
2465
2467 INLINE interval operator *(const rvector & rv1, const ivector &rv2)
2468#if(CXSC_INDEX_CHECK)
2469;
2470#else
2471 noexcept;
2472#endif
2474 INLINE interval operator *(const rvector_slice &sl, const ivector &rv)
2475#if(CXSC_INDEX_CHECK)
2476;
2477#else
2478 noexcept;
2479#endif
2481 INLINE interval operator *(const rvector &rv, const ivector_slice &sl)
2482#if(CXSC_INDEX_CHECK)
2483;
2484#else
2485 noexcept;
2486#endif
2488 INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2)
2489#if(CXSC_INDEX_CHECK)
2490;
2491#else
2492 noexcept;
2493#endif
2494
2496 INLINE interval operator *(const ivector & rv1, const rvector &rv2)
2497#if(CXSC_INDEX_CHECK)
2498;
2499#else
2500 noexcept;
2501#endif
2503 INLINE interval operator *(const ivector_slice &sl, const rvector &rv)
2504#if(CXSC_INDEX_CHECK)
2505;
2506#else
2507 noexcept;
2508#endif
2510 INLINE interval operator *(const ivector &rv, const rvector_slice &sl)
2511#if(CXSC_INDEX_CHECK)
2512;
2513#else
2514 noexcept;
2515#endif
2517 INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2)
2518#if(CXSC_INDEX_CHECK)
2519;
2520#else
2521 noexcept;
2522#endif
2523
2525 INLINE ivector operator +(const rvector &rv1, const ivector &rv2)
2526#if(CXSC_INDEX_CHECK)
2527;
2528#else
2529 noexcept;
2530#endif
2532 INLINE ivector operator +(const rvector &rv, const ivector_slice &sl)
2533#if(CXSC_INDEX_CHECK)
2534;
2535#else
2536 noexcept;
2537#endif
2539 INLINE ivector operator +(const rvector_slice &sl, const ivector &rv)
2540#if(CXSC_INDEX_CHECK)
2541;
2542#else
2543 noexcept;
2544#endif
2546 INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2)
2547#if(CXSC_INDEX_CHECK)
2548;
2549#else
2550 noexcept;
2551#endif
2552
2554 INLINE ivector operator +(const ivector &rv1, const rvector &rv2)
2555#if(CXSC_INDEX_CHECK)
2556;
2557#else
2558 noexcept;
2559#endif
2561 INLINE ivector operator +(const ivector &rv, const rvector_slice &sl)
2562#if(CXSC_INDEX_CHECK)
2563;
2564#else
2565 noexcept;
2566#endif
2568 INLINE ivector operator +(const ivector_slice &sl, const rvector &rv)
2569#if(CXSC_INDEX_CHECK)
2570;
2571#else
2572 noexcept;
2573#endif
2575 INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2)
2576#if(CXSC_INDEX_CHECK)
2577;
2578#else
2579 noexcept;
2580#endif
2581
2583 INLINE ivector & operator +=(ivector &rv1, const rvector &rv2)
2584#if(CXSC_INDEX_CHECK)
2585;
2586#else
2587 noexcept;
2588#endif
2590 INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl)
2591#if(CXSC_INDEX_CHECK)
2592;
2593#else
2594 noexcept;
2595#endif
2596
2598 INLINE ivector operator -(const rvector &rv1, const ivector &rv2)
2599#if(CXSC_INDEX_CHECK)
2600;
2601#else
2602 noexcept;
2603#endif
2605 INLINE ivector operator -(const rvector &rv, const ivector_slice &sl)
2606#if(CXSC_INDEX_CHECK)
2607;
2608#else
2609 noexcept;
2610#endif
2612 INLINE ivector operator -(const rvector_slice &sl, const ivector &rv)
2613#if(CXSC_INDEX_CHECK)
2614;
2615#else
2616 noexcept;
2617#endif
2619 INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2)
2620#if(CXSC_INDEX_CHECK)
2621;
2622#else
2623 noexcept;
2624#endif
2625
2627 INLINE ivector operator -(const ivector &rv1, const rvector &rv2)
2628#if(CXSC_INDEX_CHECK)
2629;
2630#else
2631 noexcept;
2632#endif
2634 INLINE ivector operator -(const ivector &rv, const rvector_slice &sl)
2635#if(CXSC_INDEX_CHECK)
2636;
2637#else
2638 noexcept;
2639#endif
2641 INLINE ivector operator -(const ivector_slice &sl, const rvector &rv)
2642#if(CXSC_INDEX_CHECK)
2643;
2644#else
2645 noexcept;
2646#endif
2648 INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2)
2649#if(CXSC_INDEX_CHECK)
2650;
2651#else
2652 noexcept;
2653#endif
2654
2656 INLINE ivector & operator -=(ivector &rv1, const rvector &rv2)
2657#if(CXSC_INDEX_CHECK)
2658;
2659#else
2660 noexcept;
2661#endif
2663 INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl)
2664#if(CXSC_INDEX_CHECK)
2665;
2666#else
2667 noexcept;
2668#endif
2669
2671 INLINE ivector operator |(const rvector &rv1, const rvector &rv2)
2672#if(CXSC_INDEX_CHECK)
2673;
2674#else
2675 noexcept;
2676#endif
2678 INLINE ivector operator |(const rvector &rv, const rvector_slice &sl)
2679#if(CXSC_INDEX_CHECK)
2680;
2681#else
2682 noexcept;
2683#endif
2685 INLINE ivector operator |(const rvector_slice &sl, const rvector &rv)
2686#if(CXSC_INDEX_CHECK)
2687;
2688#else
2689 noexcept;
2690#endif
2692 INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2)
2693#if(CXSC_INDEX_CHECK)
2694;
2695#else
2696 noexcept;
2697#endif
2699 INLINE ivector operator |(const rvector &rv1, const ivector &rv2)
2700#if(CXSC_INDEX_CHECK)
2701;
2702#else
2703 noexcept;
2704#endif
2706 INLINE ivector operator |(const rvector &rv, const ivector_slice &sl)
2707#if(CXSC_INDEX_CHECK)
2708;
2709#else
2710 noexcept;
2711#endif
2713 INLINE ivector operator |(const rvector_slice &sl, const ivector &rv)
2714#if(CXSC_INDEX_CHECK)
2715;
2716#else
2717 noexcept;
2718#endif
2720 INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2)
2721#if(CXSC_INDEX_CHECK)
2722;
2723#else
2724 noexcept;
2725#endif
2726
2728 INLINE ivector operator |(const ivector &rv1, const rvector &rv2)
2729#if(CXSC_INDEX_CHECK)
2730;
2731#else
2732 noexcept;
2733#endif
2735 INLINE ivector operator |(const ivector &rv, const rvector_slice &sl)
2736#if(CXSC_INDEX_CHECK)
2737;
2738#else
2739 noexcept;
2740#endif
2742 INLINE ivector operator |(const ivector_slice &sl, const rvector &rv)
2743#if(CXSC_INDEX_CHECK)
2744;
2745#else
2746 noexcept;
2747#endif
2749 INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2)
2750#if(CXSC_INDEX_CHECK)
2751;
2752#else
2753 noexcept;
2754#endif
2755
2757 INLINE ivector & operator |=(ivector &rv1, const rvector &rv2)
2758#if(CXSC_INDEX_CHECK)
2759;
2760#else
2761 noexcept;
2762#endif
2764 INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl)
2765#if(CXSC_INDEX_CHECK)
2766;
2767#else
2768 noexcept;
2769#endif
2770
2772 INLINE ivector operator &(const rvector &rv1, const ivector &rv2)
2773#if(CXSC_INDEX_CHECK)
2774;
2775#else
2776 noexcept;
2777#endif
2779 INLINE ivector operator &(const rvector &rv, const ivector_slice &sl)
2780#if(CXSC_INDEX_CHECK)
2781;
2782#else
2783 noexcept;
2784#endif
2786 INLINE ivector operator &(const rvector_slice &sl, const ivector &rv)
2787#if(CXSC_INDEX_CHECK)
2788;
2789#else
2790 noexcept;
2791#endif
2793 INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2)
2794#if(CXSC_INDEX_CHECK)
2795;
2796#else
2797 noexcept;
2798#endif
2799
2801 INLINE ivector operator &(const ivector &rv1, const rvector &rv2)
2802#if(CXSC_INDEX_CHECK)
2803;
2804#else
2805 noexcept;
2806#endif
2808 INLINE ivector operator &(const ivector &rv, const rvector_slice &sl)
2809#if(CXSC_INDEX_CHECK)
2810;
2811#else
2812 noexcept;
2813#endif
2815 INLINE ivector operator &(const ivector_slice &sl, const rvector &rv)
2816#if(CXSC_INDEX_CHECK)
2817;
2818#else
2819 noexcept;
2820#endif
2822 INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2)
2823#if(CXSC_INDEX_CHECK)
2824;
2825#else
2826 noexcept;
2827#endif
2828
2830 INLINE ivector & operator &=(ivector &rv1, const rvector &rv2)
2831#if(CXSC_INDEX_CHECK)
2832;
2833#else
2834 noexcept;
2835#endif
2837 INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl)
2838#if(CXSC_INDEX_CHECK)
2839;
2840#else
2841 noexcept;
2842#endif
2843
2845extern int in ( const ivector&, const ivector& );
2847extern int in ( int, ivector& );
2849extern ivector Blow ( const ivector&, real );
2851extern int Disjoint ( ivector&, ivector& );
2853extern int Zero ( ivector& );
2855extern rvector mid ( ivector& );
2857extern real MaxRelDiam ( const ivector& );
2859extern real MaxRelDiam ( const ivector_slice& );
2861extern int UlpAcc ( ivector&, int );
2863extern void DoubleSize ( ivector& );
2864
2865
2866} // namespace cxsc
2867
2868#ifdef _CXSC_INCL_INL
2869#include "vector.inl"
2870#include "ivector.inl"
2871#endif
2872
2873#ifdef _CXSC_RMATRIX_HPP_INCLUDED
2874# ifdef _CXSC_INCL_INL
2875# include "ivecrmat.inl"
2876# else
2877# include "ivecrmat.hpp"
2878# endif
2879#endif
2880
2881#ifdef _CXSC_CMATRIX_HPP_INCLUDED
2882# ifdef _CXSC_INCL_INL
2883# include "iveccmat.inl"
2884# else
2885# include "iveccmat.hpp"
2886# endif
2887#endif
2888
2889#ifdef _CXSC_LRMATRIX_HPP_INCLUDED
2890# ifdef _CXSC_INCL_INL
2891# include "iveclrmat.inl"
2892# else
2893# include "iveclrmat.hpp"
2894# endif
2895#endif
2896
2897#ifdef _CXSC_CVECTOR_HPP_INCLUDED
2898# ifdef _CXSC_INCL_INL
2899# include "iveccvec.inl"
2900# else
2901# include "iveccvec.hpp"
2902# endif
2903#endif
2904
2905#ifdef _CXSC_LRVECTOR_HPP_INCLUDED
2906# ifdef _CXSC_INCL_INL
2907# include "lrvecivec.inl"
2908# else
2909# include "lrvecivec.hpp"
2910# endif
2911#endif
2912
2913#ifdef CXSC_USE_BLAS
2914#define _CXSC_BLAS_IVECTOR
2915#include "cxsc_blas.inl"
2916#endif
2917
2918#endif
The Data Type cimatrix.
Definition cimatrix.hpp:908
The Data Type civector.
Definition civector.hpp:57
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix_subv.
Definition imatrix.hpp:56
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
interval()
Constructor of class interval.
Definition interval.hpp:64
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector_slice.
Definition ivector.hpp:963
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition ivector.inl:126
ivector_slice(const ivector_slice &a) noexcept
Constructor of class ivector_slice.
Definition ivector.hpp:1311
ivector_slice & operator|=(const ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition ivector.inl:726
ivector_slice & operator+=(const ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition ivector.inl:610
ivector_slice & operator-=(const ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition ivector.inl:669
ivector_slice & operator*=(const interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition ivector.inl:496
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
ivector_slice & operator/=(const interval &r) noexcept
Implementation of division and allocation operation.
Definition ivector.inl:501
ivector_slice(ivector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class ivector_slice.
Definition ivector.hpp:1308
friend int Lb(const ivector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition ivector.hpp:1398
friend int VecLen(const ivector_slice &sl) noexcept
Returns the dimension of the vector.
Definition ivector.hpp:1402
ivector_slice & operator&=(const ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition ivector.inl:783
friend int Ub(const ivector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition ivector.hpp:1400
ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition ivector.hpp:1420
ivector_slice(ivector &a, const int &lb, const int &ub) noexcept
Constructor of class ivector_slice.
Definition ivector.hpp:1306
The Data Type ivector.
Definition ivector.hpp:55
friend ivector & SetUb(ivector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition ivector.hpp:916
friend ivector & SetLb(ivector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition ivector.hpp:914
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator
friend int Ub(const ivector &rv) noexcept
Returns the upper bound of the vector.
Definition ivector.hpp:910
ivector & operator=(const ivector &rv) noexcept
Implementation of standard assigning operator.
Definition ivector.inl:263
friend int Lb(const ivector &rv) noexcept
Returns the lower bound of the vector.
Definition ivector.hpp:908
ivector & operator()() noexcept
Operator for accessing the whole vector.
Definition ivector.hpp:934
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator
ivector() noexcept
Constructor of class ivector.
Definition ivector.inl:31
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition ivector.inl:100
friend int VecLen(const ivector &rv) noexcept
Returns the dimension of the vector.
Definition ivector.hpp:912
The Multiple-Precision Data Type l_imatrix.
The Multiple-Precision Data Type l_ivector.
Definition l_ivector.hpp:55
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
Helper class for slices of sparse vectors.
A sparse interval vector.
Definition sivector.hpp:59
Helper class for slices of sparse vectors.
Definition srvector.hpp:868
A sparse real vector.
Definition srvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition interval.cpp:288
INLINE ivector _ivector(const rmatrix &sl) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition ivecrmat.inl:57
real MaxRelDiam(const imatrix_subv &v)
Computes the relative diameter .
Definition imatrix.cpp:76
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
int UlpAcc(const interval &x, int n)
Checks if the diameter of the interval is ulps.
Definition interval.cpp:335
rvector absmax(const imatrix_subv &mv) noexcept
Returns the absolute maximum value of the matrix.
Definition imatrix.inl:502
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
rvector absmin(const imatrix_subv &mv) noexcept
Returns the absolute minimum value of the matrix.
Definition imatrix.inl:496
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition cimatrix.cpp:83
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
int Zero(ivector &x)
Checks if vector is zero vector.
Definition ivector.cpp:80
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.