C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_ivector.inl
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: l_ivector.inl,v 1.20 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIVECTOR_INL_INCLUDED
27 #define _CXSC_LIVECTOR_INL_INCLUDED
28 
29 namespace cxsc {
30 
31  INLINE l_ivector::l_ivector () throw():dat(NULL),l(1),u(0),size(0)
32  {
33  }
34 
35  INLINE l_ivector::l_ivector(const int &i) throw():l(1),u(i),size(i)
36  {
37  dat=new l_interval[i];
38  }
39 
40 #ifdef OLD_CXSC
41  INLINE l_ivector::l_ivector(const class index &i) throw():l(1),u(i._int()),size(i._int())
42  {
43  dat=new l_interval[i._int()];
44  }
45 #endif
46 
47  INLINE l_ivector::l_ivector(const int &i1,const int &i2)
48 #if(CXSC_INDEX_CHECK)
49  throw(ERROR_LIVECTOR_WRONG_BOUNDARIES,ERROR_LIVECTOR_NO_MORE_MEMORY):l(i1),u(i2),size(i2-i1+1)
50 #else
51  throw():l(i1),u(i2),size(i2-i1+1)
52 #endif
53  {
54 #if(CXSC_INDEX_CHECK)
55  if(i1>i2) cxscthrow(ERROR_LIVECTOR_WRONG_BOUNDARIES("l_ivector::l_ivector(const int &i1,const int &i2)"));
56 #endif
57  dat=new l_interval[size];
58  }
59 
60  INLINE l_ivector::l_ivector(const l_ivector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
61  {
62  dat=new l_interval[size];
63  for(int i=0, j=l-rs.l;i<size;i++,j++)
64  dat[i]=rs.dat[j];
65  }
66 
67  INLINE l_ivector::l_ivector(const l_rvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
68  {
69  dat=new l_interval[size];
70  for(int i=0, j=l-rs.l;i<size;i++,j++)
71  dat[i]=rs.dat[j];
72  }
73 
74  INLINE l_ivector::l_ivector(const ivector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
75  {
76  dat=new l_interval[size];
77  for(int i=0, j=l-rs.l;i<size;i++,j++)
78  dat[i]=rs.dat[j];
79  }
80 
81  INLINE l_ivector::l_ivector(const rvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
82  {
83  dat=new l_interval[size];
84  for(int i=0, j=l-rs.l;i<size;i++,j++)
85  dat[i]=rs.dat[j];
86  }
87 
88  INLINE l_ivector::l_ivector(const l_ivector &v) throw():l(v.l),u(v.u),size(v.size)
89  {
90  dat=new l_interval[size];
91  for (int i=0;i<size;i++)
92  dat[i]=v.dat[i];
93  }
94 
95  INLINE l_ivector::l_ivector(const l_interval &r) throw():l(1),u(1),size(1)
96  {
97  dat=new l_interval[1];
98  *dat=r;
99  }
100 
101  INLINE l_ivector::l_ivector(const l_rvector &v) throw():l(v.l),u(v.u),size(v.size)
102  {
103  dat=new l_interval[size];
104  for (int i=0;i<size;i++)
105  dat[i]=v.dat[i];
106  }
107 
108  INLINE l_ivector::l_ivector(const ivector &v) throw():l(v.l),u(v.u),size(v.size)
109  {
110  dat=new l_interval[size];
111  for (int i=0;i<size;i++)
112  dat[i]=v.dat[i];
113  }
114 
115  INLINE l_ivector::l_ivector(const rvector &v) throw():l(v.l),u(v.u),size(v.size)
116  {
117  dat=new l_interval[size];
118  for (int i=0;i<size;i++)
119  dat[i]=v.dat[i];
120  }
121 
122  INLINE l_ivector::l_ivector(const real &r) throw():l(1),u(1),size(1)
123  {
124  dat=new l_interval[1];
125  *dat=r;
126  }
127 
128  INLINE l_ivector::l_ivector(const interval &r) throw():l(1),u(1),size(1)
129  {
130  dat=new l_interval[1];
131  *dat=r;
132  }
133 
134  INLINE l_ivector::l_ivector(const l_real &r) throw():l(1),u(1),size(1)
135  {
136  dat=new l_interval[1];
137  *dat=r;
138  }
139 
140 
141  INLINE l_interval & l_ivector::operator [](const int &i) const
142 #if(CXSC_INDEX_CHECK)
143  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
144 #else
145  throw()
146 #endif
147  {
148 #if(CXSC_INDEX_CHECK)
149  if(i<l||i>u) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval & l_ivector::operator [](const int &i)"));
150 #endif
151  return dat[i-l];
152  }
153 
154  INLINE l_interval & l_ivector_slice::operator [](const int &i) const
155 #if(CXSC_INDEX_CHECK)
156  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
157 #else
158  throw()
159 #endif
160  {
161 #if(CXSC_INDEX_CHECK)
162  if(i<start||i>end) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval & l_ivector_slice::operator [](const int &i)"));
163 #endif
164  return dat[i-l];
165  }
166 
168 #if(CXSC_INDEX_CHECK)
169  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
170 #else
171  throw()
172 #endif
173  {
174 #if(CXSC_INDEX_CHECK)
175  if(1<l||i>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector::operator ()(const int &i)"));
176 #endif
177  return l_ivector_slice(*this,1,i);
178  }
179 
180  INLINE l_ivector_slice l_ivector::operator ()(const int &i1,const int &i2)
181 #if(CXSC_INDEX_CHECK)
182  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
183 #else
184  throw()
185 #endif
186  {
187 #if(CXSC_INDEX_CHECK)
188  if(i1<l||i2>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector::operator ()(const int &i1,const int &i2)"));
189 #endif
190  return l_ivector_slice(*this,i1,i2);
191  }
192 
194 #if(CXSC_INDEX_CHECK)
195  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
196 #else
197  throw()
198 #endif
199  {
200 #if(CXSC_INDEX_CHECK)
201  if(1<start||i>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector_slice::operator ()(const int &i)"));
202 #endif
203  return l_ivector_slice(*this,1,i);
204  }
205 
206  INLINE l_ivector_slice l_ivector_slice::operator ()(const int &i1,const int &i2)
207 #if(CXSC_INDEX_CHECK)
208  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
209 #else
210  throw()
211 #endif
212  {
213 #if(CXSC_INDEX_CHECK)
214  if(i1<start||i2>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector_slice::operator ()(const int &i1,const int &i2)"));
215 #endif
216  return l_ivector_slice(*this,i1,i2);
217  }
218 
220 #if(CXSC_INDEX_CHECK)
221  throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ)
222 #else
223  throw()
224 #endif
225  {
226 #if(CXSC_INDEX_CHECK)
227  if(rv.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ("l_interval::l_interval(const l_ivector &rv)"));
228  else if(rv.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ("l_interval::l_interval(const l_ivector &rv)"));
229 #endif
230  *this=rv.dat[0];
231  }
232 
234 #if(CXSC_INDEX_CHECK)
235  throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ)
236 #else
237  throw()
238 #endif
239  {
240 #if(CXSC_INDEX_CHECK)
241  if(sl.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ("l_interval::l_interval(const l_ivector_slice &sl)"));
242  else if(sl.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ("l_interval::l_interval(const l_ivector_slice &sl)"));
243 #endif
244  *this=sl.dat[sl.start-sl.l];
245  }
246 
252  INLINE l_ivector _l_ivector(const l_interval &r) throw() { return l_ivector(r); }
253 
259  INLINE l_ivector _l_ivector(const real &r) throw() { return l_ivector(r); }
265  INLINE l_ivector _l_ivector(const rvector_slice &rs) throw() { return l_ivector(rs); }
271  INLINE l_ivector _l_ivector(const rvector &rs) throw() { return l_ivector(rs); }
272 
278  INLINE l_ivector _l_ivector(const l_real &r) throw() { return l_ivector(r); }
284  INLINE l_ivector _l_ivector(const l_rvector_slice &rs) throw() { return l_ivector(rs); }
290  INLINE l_ivector _l_ivector(const l_rvector &rs) throw() { return l_ivector(rs); }
291 
297  INLINE l_ivector _l_ivector(const interval &r) throw() { return l_ivector(r); }
303  INLINE l_ivector _l_ivector(const ivector_slice &rs) throw() { return l_ivector(rs); }
309  INLINE l_ivector _l_ivector(const ivector &rs) throw() { return l_ivector(rs); }
310 
311  INLINE l_ivector &l_ivector::operator =(const l_ivector &rv) throw() { return _vvassign<l_ivector,l_ivector,l_interval>(*this,rv); }
312  INLINE l_ivector &l_ivector::operator =(const l_interval &r) throw() { return _vsassign<l_ivector,l_interval>(*this,r); }
313  INLINE l_ivector::operator void*() throw() { return _vvoid(*this); }
315 #if(CXSC_INDEX_CHECK)
316  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
317 #else
318  throw()
319 #endif
320  { return _vsvsassign(*this,sl); }
322 #if(CXSC_INDEX_CHECK)
323  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
324 #else
325  throw()
326 #endif
327  { return _vsvassign(*this,rv); }
328  INLINE l_ivector_slice & l_ivector_slice::operator =(const l_interval &r) throw() { return _vssassign<l_ivector_slice,l_interval>(*this,r); }
329  INLINE l_ivector_slice::operator void*() throw() { return _vsvoid(*this); }
330 
331 //=======================================================================
332 //======================== Vector Functions =============================
333 
334 
335  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv)
336 #if(CXSC_INDEX_CHECK)
337  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
338 #else
339  throw()
340 #endif
341  { return _vvsetinf(iv,rv); }
342  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv)
343 #if(CXSC_INDEX_CHECK)
344  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
345 #else
346  throw()
347 #endif
348  { return _vsvsetinf(iv,rv); }
349  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
350 #if(CXSC_INDEX_CHECK)
351  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
352 #else
353  throw()
354 #endif
355  { return _vvssetinf(iv,rv); }
356  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
357 #if(CXSC_INDEX_CHECK)
358  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
359 #else
360  throw()
361 #endif
362  { return _vsvssetinf(iv,rv); }
363  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
364 #if(CXSC_INDEX_CHECK)
365  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
366 #else
367  throw()
368 #endif
369  { return _vvusetinf(iv,rv); }
370  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv)
371 #if(CXSC_INDEX_CHECK)
372  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
373 #else
374  throw()
375 #endif
376  { return _vsvusetinf(iv,rv); }
377  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
378 #if(CXSC_INDEX_CHECK)
379  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
380 #else
381  throw()
382 #endif
383  { return _vvsusetinf(iv,rv); }
384  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
385 #if(CXSC_INDEX_CHECK)
386  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
387 #else
388  throw()
389 #endif
390  { return _vsvsusetinf(iv,rv); }
391 
392  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv)
393 #if(CXSC_INDEX_CHECK)
394  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
395 #else
396  throw()
397 #endif
398  { return _vvsetsup(iv,rv); }
399  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv)
400 #if(CXSC_INDEX_CHECK)
401  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
402 #else
403  throw()
404 #endif
405  { return _vsvsetsup(iv,rv); }
406  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
407 #if(CXSC_INDEX_CHECK)
408  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
409 #else
410  throw()
411 #endif
412  { return _vvssetsup(iv,rv); }
413  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
414 #if(CXSC_INDEX_CHECK)
415  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
416 #else
417  throw()
418 #endif
419  { return _vsvssetsup(iv,rv); }
420  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
421 #if(CXSC_INDEX_CHECK)
422  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
423 #else
424  throw()
425 #endif
426  { return _vvusetsup(iv,rv); }
427  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv)
428 #if(CXSC_INDEX_CHECK)
429  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
430 #else
431  throw()
432 #endif
433  { return _vsvusetsup(iv,rv); }
434  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
435 #if(CXSC_INDEX_CHECK)
436  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
437 #else
438  throw()
439 #endif
440  { return _vvsusetsup(iv,rv); }
441  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
442 #if(CXSC_INDEX_CHECK)
443  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
444 #else
445  throw()
446 #endif
447  { return _vsvsusetsup(iv,rv); }
448 
449  INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) throw() { return _vssetsup(iv,r); }
450  INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) throw() { return _vssetinf(iv,r); }
451  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) throw() { return _vsusetsup(iv,r); }
452  INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) throw() { return _vsusetinf(iv,r); }
453 
454  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) throw() { return _vsssetsup(iv,r); }
455  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) throw() { return _vsssetinf(iv,r); }
456  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) throw() { return _vssusetsup(iv,r); }
457  INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) throw() { return _vssusetinf(iv,r); }
458 
459  INLINE void Resize(l_ivector &rv) throw() { _vresize(rv); }
460  INLINE void Resize(l_ivector &rv, const int &len)
461 #if(CXSC_INDEX_CHECK)
462  throw(ERROR__WRONG_BOUNDARIES<l_ivector>)
463 #else
464  throw()
465 #endif
466  { _vresize<class l_ivector,class l_interval>(rv,len); }
467  INLINE void Resize(l_ivector &rv, const int &lb, const int &ub)
468 #if(CXSC_INDEX_CHECK)
469  throw(ERROR__WRONG_BOUNDARIES<l_ivector>)
470 #else
471  throw()
472 #endif
473  { _vresize<class l_ivector,class l_interval>(rv,lb,ub); }
474 
475  INLINE l_ivector abs(const l_ivector &rv) throw() { return _vabs<l_ivector,l_ivector>(rv); }
476  INLINE l_ivector abs(const l_ivector_slice &sl) throw() { return _vsabs<l_ivector_slice,l_ivector>(sl); }
477  INLINE l_rvector diam(const l_ivector &v) throw() { return _vdiam<l_ivector,l_rvector>(v); }
478  INLINE l_rvector diam(const l_ivector_slice &v) throw() { return _vsdiam<l_ivector_slice,l_rvector>(v); }
479  INLINE l_rvector mid(const l_ivector &v) throw() { return _vmid<l_ivector,l_rvector>(v); }
480  INLINE l_rvector mid(const l_ivector_slice &v) throw() { return _vsmid<l_ivector_slice,l_rvector>(v); }
481  INLINE l_rvector Inf(const l_ivector &v) throw() { return _vinf<l_ivector,l_rvector>(v); }
482  INLINE l_rvector Inf(const l_ivector_slice &v) throw() { return _vsinf<l_ivector_slice,l_rvector>(v); }
483  INLINE l_rvector Sup(const l_ivector &v) throw() { return _vsup<l_ivector,l_rvector>(v); }
484  INLINE l_rvector Sup(const l_ivector_slice &v) throw() { return _vssup<l_ivector_slice,l_rvector>(v); }
485  INLINE bool operator !(const l_ivector &rv) throw() { return _vnot(rv); }
486  INLINE bool operator !(const l_ivector_slice &sl) throw() { return _vsnot(sl); }
487 
488 //======================= Vector / Scalar ===============================
489 
490 //----------------------------- l_interval ---------------------------
491 
492  INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) throw() { return _vsmult<l_ivector,l_interval,l_ivector>(rv,s); }
493  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) throw() { return _vssmult<l_ivector_slice,l_interval,l_ivector>(sl,s); }
494  INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) throw() { return _vsmult<l_ivector,l_interval,l_ivector>(rv,s); }
495  INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) throw() { return _vssmult<l_ivector_slice,l_interval,l_ivector>(sl,s); }
496  INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) throw() { return _vsmultassign(rv,r); }
497  INLINE l_ivector_slice &l_ivector_slice::operator *=(const l_interval &r) throw() { return _vssmultassign(*this,r); }
498 
499  INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) throw() { return _vsdiv<l_ivector,l_interval,l_ivector>(rv,s); }
500  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) throw() { return _vssdiv<l_ivector_slice,l_interval,l_ivector>(sl,s); }
501  INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) throw() { return _vsdivassign(rv,r); }
502  INLINE l_ivector_slice &l_ivector_slice::operator /=(const l_interval &r) throw() { return _vssdivassign(*this,r); }
503 
504 //---------------------------- Real --------------------------------------
505 
506  INLINE l_ivector operator *(const l_ivector &rv, const real &s) throw() { return _vsmult<l_ivector,real,l_ivector>(rv,s); }
507  INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) throw() { return _vssmult<l_ivector_slice,real,l_ivector>(sl,s); }
508  INLINE l_ivector operator *(const real &s, const l_ivector &rv) throw() { return _vsmult<l_ivector,real,l_ivector>(rv,s); }
509  INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) throw() { return _vssmult<l_ivector_slice,real,l_ivector>(sl,s); }
510  INLINE l_ivector &operator *=(l_ivector &rv,const real &r) throw() { return _vsmultassign(rv,r); }
511  INLINE l_ivector_slice &l_ivector_slice::operator *=(const real &r) throw() { return _vssmultassign(*this,r); }
512 
513  INLINE l_ivector operator /(const l_ivector &rv, const real &s) throw() { return _vsdiv<l_ivector,real,l_ivector>(rv,s); }
514  INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) throw() { return _vssdiv<l_ivector_slice,real,l_ivector>(sl,s); }
515  INLINE l_ivector &operator /=(l_ivector &rv,const real &r) throw() { return _vsdivassign(rv,r); }
516  INLINE l_ivector_slice &l_ivector_slice::operator /=(const real &r) throw() { return _vssdivassign(*this,r); }
517 
518  INLINE l_ivector operator *(const rvector &rv, const l_interval &s) throw() { return _vsmult<rvector,l_interval,l_ivector>(rv,s); }
519  INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) throw() { return _vssmult<rvector_slice,l_interval,l_ivector>(sl,s); }
520  INLINE l_ivector operator *(const l_interval &s, const rvector &rv) throw() { return _vsmult<rvector,l_interval,l_ivector>(rv,s); }
521  INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) throw() { return _vssmult<rvector_slice,l_interval,l_ivector>(sl,s); }
522 
523  INLINE l_ivector operator /(const rvector &rv, const l_interval &s) throw() { return _vsdiv<rvector,l_interval,l_ivector>(rv,s); }
524  INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) throw() { return _vssdiv<rvector_slice,l_interval,l_ivector>(sl,s); }
525 
526 //---------------------------- l_real --------------------------------------
527 
528  INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) throw() { return _vsmult<l_ivector,l_real,l_ivector>(rv,s); }
529  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) throw() { return _vssmult<l_ivector_slice,l_real,l_ivector>(sl,s); }
530  INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) throw() { return _vsmult<l_ivector,l_real,l_ivector>(rv,s); }
531  INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) throw() { return _vssmult<l_ivector_slice,l_real,l_ivector>(sl,s); }
532  INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) throw() { return _vsmultassign(rv,r); }
533  INLINE l_ivector_slice &l_ivector_slice::operator *=(const l_real &r) throw() { return _vssmultassign(*this,r); }
534 
535  INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) throw() { return _vsdiv<l_ivector,l_real,l_ivector>(rv,s); }
536  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) throw() { return _vssdiv<l_ivector_slice,l_real,l_ivector>(sl,s); }
537  INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) throw() { return _vsdivassign(rv,r); }
538  INLINE l_ivector_slice &l_ivector_slice::operator /=(const l_real &r) throw() { return _vssdivassign(*this,r); }
539 
540  INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) throw() { return _vsmult<l_rvector,l_interval,l_ivector>(rv,s); }
541  INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) throw() { return _vssmult<l_rvector_slice,l_interval,l_ivector>(sl,s); }
542  INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) throw() { return _vsmult<l_rvector,l_interval,l_ivector>(rv,s); }
543  INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) throw() { return _vssmult<l_rvector_slice,l_interval,l_ivector>(sl,s); }
544 
545  INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) throw() { return _vsdiv<l_rvector,l_interval,l_ivector>(rv,s); }
546  INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) throw() { return _vssdiv<l_rvector_slice,l_interval,l_ivector>(sl,s); }
547 
548 //---------------------------- interval --------------------------------------
549 
550  INLINE l_ivector operator *(const l_ivector &rv, const interval &s) throw() { return _vsmult<l_ivector,interval,l_ivector>(rv,s); }
551  INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) throw() { return _vssmult<l_ivector_slice,interval,l_ivector>(sl,s); }
552  INLINE l_ivector operator *(const interval &s, const l_ivector &rv) throw() { return _vsmult<l_ivector,interval,l_ivector>(rv,s); }
553  INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) throw() { return _vssmult<l_ivector_slice,interval,l_ivector>(sl,s); }
554  INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) throw() { return _vsmultassign(rv,r); }
555  INLINE l_ivector_slice &l_ivector_slice::operator *=(const interval &r) throw() { return _vssmultassign(*this,r); }
556 
557  INLINE l_ivector operator /(const l_ivector &rv, const interval &s) throw() { return _vsdiv<l_ivector,interval,l_ivector>(rv,s); }
558  INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) throw() { return _vssdiv<l_ivector_slice,interval,l_ivector>(sl,s); }
559  INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) throw() { return _vsdivassign(rv,r); }
560  INLINE l_ivector_slice &l_ivector_slice::operator /=(const interval &r) throw() { return _vssdivassign(*this,r); }
561 
562  INLINE l_ivector operator *(const ivector &rv, const l_interval &s) throw() { return _vsmult<ivector,l_interval,l_ivector>(rv,s); }
563  INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) throw() { return _vssmult<ivector_slice,l_interval,l_ivector>(sl,s); }
564  INLINE l_ivector operator *(const l_interval &s, const ivector &rv) throw() { return _vsmult<ivector,l_interval,l_ivector>(rv,s); }
565  INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) throw() { return _vssmult<ivector_slice,l_interval,l_ivector>(sl,s); }
566 
567  INLINE l_ivector operator /(const ivector &rv, const l_interval &s) throw() { return _vsdiv<ivector,l_interval,l_ivector>(rv,s); }
568  INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) throw() { return _vssdiv<ivector_slice,l_interval,l_ivector>(sl,s); }
569 
570 //======================= Vector / Vector ===============================
571 
572 
573  INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) throw() { return _vout(s,rv); }
574  INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) throw() { return _vsout(o,sl); }
575  INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) throw() { return _vin(s,rv); }
576  INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) throw() { return _vsin(s,rv); }
577 
578 //----------------------- l_interval / l_interval ---------------------------
579  INLINE l_ivector & l_ivector::operator =(const l_ivector_slice &sl) throw() { return _vvsassign<l_ivector,l_ivector_slice,l_interval>(*this,sl); }
580 
581  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2)
582 #if(CXSC_INDEX_CHECK)
583  throw(OP_WITH_WRONG_DIM)
584 #else
585  throw()
586 #endif
587  { _vvaccu(dp,rv1,rv2); }
588  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv)
589 #if(CXSC_INDEX_CHECK)
590  throw(OP_WITH_WRONG_DIM)
591 #else
592  throw()
593 #endif
594  { _vsvaccu(dp,sl,rv); }
595  INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl)
596 #if(CXSC_INDEX_CHECK)
597  throw(OP_WITH_WRONG_DIM)
598 #else
599  throw()
600 #endif
601  { _vsvaccu(dp,sl,rv); }
602  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
603 #if(CXSC_INDEX_CHECK)
604  throw(OP_WITH_WRONG_DIM)
605 #else
606  throw()
607 #endif
608  ;
609  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
610 #if(CXSC_INDEX_CHECK)
611  throw(OP_WITH_WRONG_DIM)
612 #else
613  throw()
614 #endif
615  ;
616  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2)
617 #if(CXSC_INDEX_CHECK)
618  throw(OP_WITH_WRONG_DIM)
619 #else
620  throw()
621 #endif
622  { _vsvsaccu(dp,sl1,sl2); }
623 
624  INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2)
625 #if(CXSC_INDEX_CHECK)
626  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
627 #else
628  throw()
629 #endif
630  { return _vvlimult<l_ivector,l_ivector,l_interval>(rv1,rv2); }
631  INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv)
632 #if(CXSC_INDEX_CHECK)
633  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
634 #else
635  throw()
636 #endif
637  { return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
638  INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl)
639 #if(CXSC_INDEX_CHECK)
640  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
641 #else
642  throw()
643 #endif
644  { return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
645  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2)
646 #if(CXSC_INDEX_CHECK)
647  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
648 #else
649  throw()
650 #endif
651  { return _vsvslimult<l_ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
652 
653  INLINE const l_ivector &operator +(const l_ivector &rv) throw() { return rv; }
654  INLINE l_ivector operator +(const l_ivector_slice &sl) throw() { return sl; }
655  INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2)
656 #if(CXSC_INDEX_CHECK)
657  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
658 #else
659  throw()
660 #endif
661  { return _vvplus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
662  INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl)
663 #if(CXSC_INDEX_CHECK)
664  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
665 #else
666  throw()
667 #endif
668  { return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
669  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv)
670 #if(CXSC_INDEX_CHECK)
671  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
672 #else
673  throw()
674 #endif
675  { return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
676  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
677 #if(CXSC_INDEX_CHECK)
678  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
679 #else
680  throw()
681 #endif
682  { return _vsvsplus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
683  INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
684 #if(CXSC_INDEX_CHECK)
685  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
686 #else
687  throw()
688 #endif
689  { return _vvplusassign(rv1,rv2); }
691 #if(CXSC_INDEX_CHECK)
692  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
693 #else
694  throw()
695 #endif
696  { return _vvsplusassign(rv,sl); }
698 #if(CXSC_INDEX_CHECK)
699  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
700 #else
701  throw()
702 #endif
703  { return _vsvplusassign(*this,rv); }
705 #if(CXSC_INDEX_CHECK)
706  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
707 #else
708  throw()
709 #endif
710  { return _vsvsplusassign(*this,sl2); }
711 
712  INLINE l_ivector operator -(const l_ivector &rv) throw() { return _vminus(rv); }
713  INLINE l_ivector operator -(const l_ivector_slice &sl) throw() { return _vsminus<l_ivector_slice,l_ivector>(sl); }
714  INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2)
715 #if(CXSC_INDEX_CHECK)
716  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
717 #else
718  throw()
719 #endif
720  { return _vvminus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
721  INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl)
722 #if(CXSC_INDEX_CHECK)
723  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
724 #else
725  throw()
726 #endif
727  { return _vvsminus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
728  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv)
729 #if(CXSC_INDEX_CHECK)
730  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
731 #else
732  throw()
733 #endif
734  { return _vsvminus<l_ivector_slice,l_ivector,l_ivector>(sl,rv); }
735  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
736 #if(CXSC_INDEX_CHECK)
737  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
738 #else
739  throw()
740 #endif
741  { return _vsvsminus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
742  INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
743 #if(CXSC_INDEX_CHECK)
744  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
745 #else
746  throw()
747 #endif
748  { return _vvminusassign(rv1,rv2); }
749  INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl)
750 #if(CXSC_INDEX_CHECK)
751  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
752 #else
753  throw()
754 #endif
755  { return _vvsminusassign(rv,sl); }
757 #if(CXSC_INDEX_CHECK)
758  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
759 #else
760  throw()
761 #endif
762  { return _vsvminusassign(*this,rv); }
764 #if(CXSC_INDEX_CHECK)
765  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
766 #else
767  throw()
768 #endif
769  { return _vsvsminusassign(*this,sl2); }
770 
771  INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2)
772 #if(CXSC_INDEX_CHECK)
773  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
774 #else
775  throw()
776 #endif
777  { return _vvconv<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
778  INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl)
779 #if(CXSC_INDEX_CHECK)
780  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
781 #else
782  throw()
783 #endif
784  { return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
785  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv)
786 #if(CXSC_INDEX_CHECK)
787  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
788 #else
789  throw()
790 #endif
791  { return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
792  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
793 #if(CXSC_INDEX_CHECK)
794  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
795 #else
796  throw()
797 #endif
798  { return _vsvsconv<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
799  INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
800 #if(CXSC_INDEX_CHECK)
801  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
802 #else
803  throw()
804 #endif
805  { return _vvconvassign(rv1,rv2); }
806  INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl)
807 #if(CXSC_INDEX_CHECK)
808  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
809 #else
810  throw()
811 #endif
812  { return _vvsconvassign(rv,sl); }
814 #if(CXSC_INDEX_CHECK)
815  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
816 #else
817  throw()
818 #endif
819  { return _vsvconvassign(*this,rv); }
821 #if(CXSC_INDEX_CHECK)
822  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
823 #else
824  throw()
825 #endif
826  { return _vsvsconvassign(*this,sl2); }
827 
828  INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2)
829 #if(CXSC_INDEX_CHECK)
830  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
831 #else
832  throw()
833 #endif
834  { return _vvsect<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
835  INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl)
836 #if(CXSC_INDEX_CHECK)
837  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
838 #else
839  throw()
840 #endif
841  { return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
842  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv)
843 #if(CXSC_INDEX_CHECK)
844  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
845 #else
846  throw()
847 #endif
848  { return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
849  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
850 #if(CXSC_INDEX_CHECK)
851  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
852 #else
853  throw()
854 #endif
855  { return _vsvssect<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
856  INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
857 #if(CXSC_INDEX_CHECK)
858  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
859 #else
860  throw()
861 #endif
862  { return _vvsectassign(rv1,rv2); }
863  INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl)
864 #if(CXSC_INDEX_CHECK)
865  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
866 #else
867  throw()
868 #endif
869  { return _vvssectassign(rv,sl); }
871 #if(CXSC_INDEX_CHECK)
872  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
873 #else
874  throw()
875 #endif
876  { return _vsvsectassign(*this,rv); }
878 #if(CXSC_INDEX_CHECK)
879  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
880 #else
881  throw()
882 #endif
883  { return _vsvssectassign(*this,sl2); }
884 
885  INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vveq(rv1,rv2); }
886  INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvseq(sl1,sl2); }
887  INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vsveq(sl,rv); }
888  INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vsveq(sl,rv); }
889  INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vvneq(rv1,rv2); }
890  INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvsneq(sl1,sl2); }
891  INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vsvneq(sl,rv); }
892  INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vsvneq(sl,rv); }
893  INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vvless(rv1,rv2); }
894  INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvsless(sl1,sl2); }
895  INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vsvless(sl,rv); }
896  INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vvsless(rv,sl); }
897  INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vvleq(rv1,rv2); }
898  INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvsleq(sl1,sl2); }
899  INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vsvleq(sl,rv); }
900  INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vvsleq(rv,sl); }
901  INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vvless(rv2,rv1); }
902  INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvsless(sl2,sl1); }
903  INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vvsless(rv,sl); }
904  INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vsvless(sl,rv); }
905  INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) throw() { return _vvleq(rv2,rv1); }
906  INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw() { return _vsvsleq(sl2,sl1); }
907  INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) throw() { return _vvsleq(rv,sl); }
908  INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) throw() { return _vsvleq(sl,rv); }
909 
910 //-------------------------------- l_interval / Real --------------------------------
911 
912  INLINE l_ivector &l_ivector::operator =(const rvector &rv) throw() { return _vvassign<l_ivector,rvector,l_interval>(*this,rv); }
913  INLINE l_ivector &l_ivector::operator =(const real &r) throw() { return _vsassign<l_ivector,real>(*this,r); }
914  INLINE l_ivector & l_ivector::operator =(const rvector_slice &sl) throw() { return _vvsassign<l_ivector,rvector_slice,l_interval>(*this,sl); }
916 #if(CXSC_INDEX_CHECK)
917  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
918 #else
919  throw()
920 #endif
921  { return _vsvassign(*this,rv); }
922  INLINE l_ivector_slice &l_ivector_slice::operator =(const real &r) throw() { return _vssassign<l_ivector_slice,real>(*this,r); }
924 #if(CXSC_INDEX_CHECK)
925  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
926 #else
927  throw()
928 #endif
929  { return _vsvsassign(*this,sl); }
930 
931  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2)
932 #if(CXSC_INDEX_CHECK)
933  throw(OP_WITH_WRONG_DIM)
934 #else
935  throw()
936 #endif
937  { _vvaccu(dp,rv1,rv2); }
938  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
939 #if(CXSC_INDEX_CHECK)
940  throw(OP_WITH_WRONG_DIM)
941 #else
942  throw()
943 #endif
944  { _vvaccu(dp,rv2,rv1); }
945  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv)
946 #if(CXSC_INDEX_CHECK)
947  throw(OP_WITH_WRONG_DIM)
948 #else
949  throw()
950 #endif
951  { _vsvaccu(dp,sl,rv); }
952  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv)
953 #if(CXSC_INDEX_CHECK)
954  throw(OP_WITH_WRONG_DIM)
955 #else
956  throw()
957 #endif
958  { _vsvaccu(dp,sl,rv); }
959  INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl)
960 #if(CXSC_INDEX_CHECK)
961  throw(OP_WITH_WRONG_DIM)
962 #else
963  throw()
964 #endif
965  { _vsvaccu(dp,sl,rv); }
966  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
967 #if(CXSC_INDEX_CHECK)
968  throw(OP_WITH_WRONG_DIM)
969 #else
970  throw()
971 #endif
972  ;
973  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
974 #if(CXSC_INDEX_CHECK)
975  throw(OP_WITH_WRONG_DIM)
976 #else
977  throw()
978 #endif
979  ;
980  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl)
981 #if(CXSC_INDEX_CHECK)
982  throw(OP_WITH_WRONG_DIM)
983 #else
984  throw()
985 #endif
986  { _vsvaccu(dp,sl,rv); }
987  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
988 #if(CXSC_INDEX_CHECK)
989  throw(OP_WITH_WRONG_DIM)
990 #else
991  throw()
992 #endif
993  ;
994  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
995 #if(CXSC_INDEX_CHECK)
996  throw(OP_WITH_WRONG_DIM)
997 #else
998  throw()
999 #endif
1000  ;
1001  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2)
1002 #if(CXSC_INDEX_CHECK)
1003  throw(OP_WITH_WRONG_DIM)
1004 #else
1005  throw()
1006 #endif
1007  { _vsvsaccu(dp,sl2,sl1); }
1008  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2)
1009 #if(CXSC_INDEX_CHECK)
1010  throw(OP_WITH_WRONG_DIM)
1011 #else
1012  throw()
1013 #endif
1014  { _vsvsaccu(dp,sl1,sl2); }
1015 
1016  INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2)
1017 #if(CXSC_INDEX_CHECK)
1018  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1019 #else
1020  throw()
1021 #endif
1022  { return _vvlimult<rvector,l_ivector,l_interval>(rv1,rv2); }
1023  INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
1024 #if(CXSC_INDEX_CHECK)
1025  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1026 #else
1027  throw()
1028 #endif
1029  { return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1030  INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
1031 #if(CXSC_INDEX_CHECK)
1032  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1033 #else
1034  throw()
1035 #endif
1036  { return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1037  INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2)
1038 #if(CXSC_INDEX_CHECK)
1039  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1040 #else
1041  throw()
1042 #endif
1043  { return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1044 
1045  INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2)
1046 #if(CXSC_INDEX_CHECK)
1047  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1048 #else
1049  throw()
1050 #endif
1051  { return _vvlimult<rvector,l_ivector,l_interval>(rv2,rv1); }
1052  INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
1053 #if(CXSC_INDEX_CHECK)
1054  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1055 #else
1056  throw()
1057 #endif
1058  { return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1059  INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
1060 #if(CXSC_INDEX_CHECK)
1061  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1062 #else
1063  throw()
1064 #endif
1065  { return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1066  INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2)
1067 #if(CXSC_INDEX_CHECK)
1068  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1069 #else
1070  throw()
1071 #endif
1072  { return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1073 
1074  INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2)
1075 #if(CXSC_INDEX_CHECK)
1076  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1077 #else
1078  throw()
1079 #endif
1080  { return _vvplus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1081  INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
1082 #if(CXSC_INDEX_CHECK)
1083  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1084 #else
1085  throw()
1086 #endif
1087  { return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1088  INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
1089 #if(CXSC_INDEX_CHECK)
1090  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1091 #else
1092  throw()
1093 #endif
1094  { return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1095  INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2)
1096 #if(CXSC_INDEX_CHECK)
1097  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1098 #else
1099  throw()
1100 #endif
1101  { return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1102 
1103  INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2)
1104 #if(CXSC_INDEX_CHECK)
1105  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1106 #else
1107  throw()
1108 #endif
1109  { return _vvplus<rvector,l_ivector,l_ivector>(rv2,rv1); }
1110  INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
1111 #if(CXSC_INDEX_CHECK)
1112  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1113 #else
1114  throw()
1115 #endif
1116  { return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1117  INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
1118 #if(CXSC_INDEX_CHECK)
1119  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1120 #else
1121  throw()
1122 #endif
1123  { return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1124  INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2)
1125 #if(CXSC_INDEX_CHECK)
1126  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1127 #else
1128  throw()
1129 #endif
1130  { return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1131 
1132  INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2)
1133 #if(CXSC_INDEX_CHECK)
1134  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1135 #else
1136  throw()
1137 #endif
1138  { return _vvplusassign(rv1,rv2); }
1140 #if(CXSC_INDEX_CHECK)
1141  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1142 #else
1143  throw()
1144 #endif
1145  { return _vvsplusassign(rv,sl); }
1147 #if(CXSC_INDEX_CHECK)
1148  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1149 #else
1150  throw()
1151 #endif
1152  { return _vsvplusassign(*this,rv); }
1154 #if(CXSC_INDEX_CHECK)
1155  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1156 #else
1157  throw()
1158 #endif
1159  { return _vsvsplusassign(*this,sl2); }
1160 
1161  INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2)
1162 #if(CXSC_INDEX_CHECK)
1163  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1164 #else
1165  throw()
1166 #endif
1167  { return _vvminus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1168  INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
1169 #if(CXSC_INDEX_CHECK)
1170  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1171 #else
1172  throw()
1173 #endif
1174  { return _vvsminus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1175  INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
1176 #if(CXSC_INDEX_CHECK)
1177  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1178 #else
1179  throw()
1180 #endif
1181  { return _vsvminus<rvector_slice,l_ivector,l_ivector>(sl,rv); }
1182  INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2)
1183 #if(CXSC_INDEX_CHECK)
1184  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1185 #else
1186  throw()
1187 #endif
1188  { return _vsvsminus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1189 
1190  INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2)
1191 #if(CXSC_INDEX_CHECK)
1192  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1193 #else
1194  throw()
1195 #endif
1196  { return _vvminus<l_ivector,rvector,l_ivector>(rv1,rv2); }
1197  INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
1198 #if(CXSC_INDEX_CHECK)
1199  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1200 #else
1201  throw()
1202 #endif
1203  { return _vvsminus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1204  INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
1205 #if(CXSC_INDEX_CHECK)
1206  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1207 #else
1208  throw()
1209 #endif
1210  { return _vsvminus<l_ivector_slice,rvector,l_ivector>(sl,rv); }
1211  INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2)
1212 #if(CXSC_INDEX_CHECK)
1213  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1214 #else
1215  throw()
1216 #endif
1217  { return _vsvsminus<l_ivector_slice,rvector_slice,l_ivector>(sl1,sl2); }
1218 
1219  INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2)
1220 #if(CXSC_INDEX_CHECK)
1221  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1222 #else
1223  throw()
1224 #endif
1225  { return _vvminusassign(rv1,rv2); }
1226  INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl)
1227 #if(CXSC_INDEX_CHECK)
1228  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1229 #else
1230  throw()
1231 #endif
1232  { return _vvsminusassign(rv,sl); }
1234 #if(CXSC_INDEX_CHECK)
1235  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1236 #else
1237  throw()
1238 #endif
1239  { return _vsvminusassign(*this,rv); }
1241 #if(CXSC_INDEX_CHECK)
1242  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1243 #else
1244  throw()
1245 #endif
1246  { return _vsvsminusassign(*this,sl2); }
1247 
1248  INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2)
1249 #if(CXSC_INDEX_CHECK)
1250  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1251 #else
1252  throw()
1253 #endif
1254  { return _vvconv<rvector,l_ivector,l_ivector>(rv1,rv2); }
1255  INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
1256 #if(CXSC_INDEX_CHECK)
1257  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1258 #else
1259  throw()
1260 #endif
1261  { return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1262  INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
1263 #if(CXSC_INDEX_CHECK)
1264  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1265 #else
1266  throw()
1267 #endif
1268  { return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1269  INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2)
1270 #if(CXSC_INDEX_CHECK)
1271  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1272 #else
1273  throw()
1274 #endif
1275  { return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1276 
1277  INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2)
1278 #if(CXSC_INDEX_CHECK)
1279  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1280 #else
1281  throw()
1282 #endif
1283  { return _vvconv<rvector,l_ivector,l_ivector>(rv2,rv1); }
1284  INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
1285 #if(CXSC_INDEX_CHECK)
1286  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1287 #else
1288  throw()
1289 #endif
1290  { return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1291  INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
1292 #if(CXSC_INDEX_CHECK)
1293  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1294 #else
1295  throw()
1296 #endif
1297  { return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1298  INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2)
1299 #if(CXSC_INDEX_CHECK)
1300  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1301 #else
1302  throw()
1303 #endif
1304  { return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1305 
1306  INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2)
1307 #if(CXSC_INDEX_CHECK)
1308  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1309 #else
1310  throw()
1311 #endif
1312  { return _vvconvassign(rv1,rv2); }
1313  INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl)
1314 #if(CXSC_INDEX_CHECK)
1315  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1316 #else
1317  throw()
1318 #endif
1319  { return _vvsconvassign(rv,sl); }
1321 #if(CXSC_INDEX_CHECK)
1322  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1323 #else
1324  throw()
1325 #endif
1326  { return _vsvconvassign(*this,rv); }
1328 #if(CXSC_INDEX_CHECK)
1329  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1330 #else
1331  throw()
1332 #endif
1333  { return _vsvsconvassign(*this,sl2); }
1334 
1335  INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2)
1336 #if(CXSC_INDEX_CHECK)
1337  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1338 #else
1339  throw()
1340 #endif
1341  { return _vvsect<rvector,l_ivector,l_ivector>(rv1,rv2); }
1342  INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
1343 #if(CXSC_INDEX_CHECK)
1344  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1345 #else
1346  throw()
1347 #endif
1348  { return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1349  INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
1350 #if(CXSC_INDEX_CHECK)
1351  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1352 #else
1353  throw()
1354 #endif
1355  { return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1356  INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2)
1357 #if(CXSC_INDEX_CHECK)
1358  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1359 #else
1360  throw()
1361 #endif
1362  { return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1363 
1364  INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2)
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1367 #else
1368  throw()
1369 #endif
1370  { return _vvsect<rvector,l_ivector,l_ivector>(rv2,rv1); }
1371  INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
1372 #if(CXSC_INDEX_CHECK)
1373  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1374 #else
1375  throw()
1376 #endif
1377  { return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1378  INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
1379 #if(CXSC_INDEX_CHECK)
1380  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1381 #else
1382  throw()
1383 #endif
1384  { return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1385  INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2)
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1388 #else
1389  throw()
1390 #endif
1391  { return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1392 
1393  INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2)
1394 #if(CXSC_INDEX_CHECK)
1395  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1396 #else
1397  throw()
1398 #endif
1399  { return _vvsectassign(rv1,rv2); }
1400  INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl)
1401 #if(CXSC_INDEX_CHECK)
1402  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1403 #else
1404  throw()
1405 #endif
1406  { return _vvssectassign(rv,sl); }
1408 #if(CXSC_INDEX_CHECK)
1409  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1410 #else
1411  throw()
1412 #endif
1413  { return _vsvsectassign(*this,rv); }
1415 #if(CXSC_INDEX_CHECK)
1416  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1417 #else
1418  throw()
1419 #endif
1420  { return _vsvssectassign(*this,sl2); }
1421 
1422 //-------------------------------- l_interval / l_real --------------------------------
1423 
1424  INLINE l_ivector &l_ivector::operator =(const l_rvector &rv) throw() { return _vvassign<l_ivector,l_rvector,l_interval>(*this,rv); }
1425  INLINE l_ivector &l_ivector::operator =(const l_real &r) throw() { return _vsassign<l_ivector,l_real>(*this,r); }
1426  INLINE l_ivector & l_ivector::operator =(const l_rvector_slice &sl) throw() { return _vvsassign<l_ivector,l_rvector_slice,l_interval>(*this,sl); }
1428 #if(CXSC_INDEX_CHECK)
1429  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1430 #else
1431  throw()
1432 #endif
1433  { return _vsvassign(*this,rv); }
1434  INLINE l_ivector_slice &l_ivector_slice::operator =(const l_real &r) throw() { return _vssassign<l_ivector_slice,l_real>(*this,r); }
1436 #if(CXSC_INDEX_CHECK)
1437  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1438 #else
1439  throw()
1440 #endif
1441  { return _vsvsassign(*this,sl); }
1442 
1443  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2)
1444 #if(CXSC_INDEX_CHECK)
1445  throw(OP_WITH_WRONG_DIM)
1446 #else
1447  throw()
1448 #endif
1449  { _vvaccu(dp,rv1,rv2); }
1450  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2)
1451 #if(CXSC_INDEX_CHECK)
1452  throw(OP_WITH_WRONG_DIM)
1453 #else
1454  throw()
1455 #endif
1456  { _vvaccu(dp,rv2,rv1); }
1457  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv)
1458 #if(CXSC_INDEX_CHECK)
1459  throw(OP_WITH_WRONG_DIM)
1460 #else
1461  throw()
1462 #endif
1463  { _vsvaccu(dp,sl,rv); }
1464  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv)
1465 #if(CXSC_INDEX_CHECK)
1466  throw(OP_WITH_WRONG_DIM)
1467 #else
1468  throw()
1469 #endif
1470  { _vsvaccu(dp,sl,rv); }
1471  INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl)
1472 #if(CXSC_INDEX_CHECK)
1473  throw(OP_WITH_WRONG_DIM)
1474 #else
1475  throw()
1476 #endif
1477  { _vsvaccu(dp,sl,rv); }
1478  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
1479 #if(CXSC_INDEX_CHECK)
1480  throw(OP_WITH_WRONG_DIM)
1481 #else
1482  throw()
1483 #endif
1484  ;
1485  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
1486 #if(CXSC_INDEX_CHECK)
1487  throw(OP_WITH_WRONG_DIM)
1488 #else
1489  throw()
1490 #endif
1491  ;
1492  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl)
1493 #if(CXSC_INDEX_CHECK)
1494  throw(OP_WITH_WRONG_DIM)
1495 #else
1496  throw()
1497 #endif
1498  { _vsvaccu(dp,sl,rv); }
1499  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
1500 #if(CXSC_INDEX_CHECK)
1501  throw(OP_WITH_WRONG_DIM)
1502 #else
1503  throw()
1504 #endif
1505  ;
1506  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
1507 #if(CXSC_INDEX_CHECK)
1508  throw(OP_WITH_WRONG_DIM)
1509 #else
1510  throw()
1511 #endif
1512  ;
1513  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2)
1514 #if(CXSC_INDEX_CHECK)
1515  throw(OP_WITH_WRONG_DIM)
1516 #else
1517  throw()
1518 #endif
1519  { _vsvsaccu(dp,sl2,sl1); }
1520  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2)
1521 #if(CXSC_INDEX_CHECK)
1522  throw(OP_WITH_WRONG_DIM)
1523 #else
1524  throw()
1525 #endif
1526  { _vsvsaccu(dp,sl1,sl2); }
1527 
1528  INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2)
1529 #if(CXSC_INDEX_CHECK)
1530  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1531 #else
1532  throw()
1533 #endif
1534  { return _vvlimult<l_rvector,l_ivector,l_interval>(rv1,rv2); }
1535  INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv)
1536 #if(CXSC_INDEX_CHECK)
1537  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1538 #else
1539  throw()
1540 #endif
1541  { return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1542  INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl)
1543 #if(CXSC_INDEX_CHECK)
1544  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1545 #else
1546  throw()
1547 #endif
1548  { return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1549  INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2)
1550 #if(CXSC_INDEX_CHECK)
1551  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1552 #else
1553  throw()
1554 #endif
1555  { return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1556 
1557  INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2)
1558 #if(CXSC_INDEX_CHECK)
1559  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1560 #else
1561  throw()
1562 #endif
1563  { return _vvlimult<l_rvector,l_ivector,l_interval>(rv2,rv1); }
1564  INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv)
1565 #if(CXSC_INDEX_CHECK)
1566  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1567 #else
1568  throw()
1569 #endif
1570  { return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1571  INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl)
1572 #if(CXSC_INDEX_CHECK)
1573  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1574 #else
1575  throw()
1576 #endif
1577  { return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1578  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2)
1579 #if(CXSC_INDEX_CHECK)
1580  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1581 #else
1582  throw()
1583 #endif
1584  { return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1585 
1586  INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2)
1587 #if(CXSC_INDEX_CHECK)
1588  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1589 #else
1590  throw()
1591 #endif
1592  { return _vvplus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1593  INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl)
1594 #if(CXSC_INDEX_CHECK)
1595  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1596 #else
1597  throw()
1598 #endif
1599  { return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1600  INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv)
1601 #if(CXSC_INDEX_CHECK)
1602  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1603 #else
1604  throw()
1605 #endif
1606  { return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1607  INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1608 #if(CXSC_INDEX_CHECK)
1609  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1610 #else
1611  throw()
1612 #endif
1613  { return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1614 
1615  INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2)
1616 #if(CXSC_INDEX_CHECK)
1617  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1618 #else
1619  throw()
1620 #endif
1621  { return _vvplus<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1622  INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl)
1623 #if(CXSC_INDEX_CHECK)
1624  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1625 #else
1626  throw()
1627 #endif
1628  { return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1629  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv)
1630 #if(CXSC_INDEX_CHECK)
1631  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1632 #else
1633  throw()
1634 #endif
1635  { return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1636  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1637 #if(CXSC_INDEX_CHECK)
1638  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1639 #else
1640  throw()
1641 #endif
1642  { return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1643 
1644  INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2)
1645 #if(CXSC_INDEX_CHECK)
1646  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1647 #else
1648  throw()
1649 #endif
1650  { return _vvplusassign(rv1,rv2); }
1652 #if(CXSC_INDEX_CHECK)
1653  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1654 #else
1655  throw()
1656 #endif
1657  { return _vvsplusassign(rv,sl); }
1659 #if(CXSC_INDEX_CHECK)
1660  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1661 #else
1662  throw()
1663 #endif
1664  { return _vsvplusassign(*this,rv); }
1666 #if(CXSC_INDEX_CHECK)
1667  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1668 #else
1669  throw()
1670 #endif
1671  { return _vsvsplusassign(*this,sl2); }
1672 
1673  INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2)
1674 #if(CXSC_INDEX_CHECK)
1675  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1676 #else
1677  throw()
1678 #endif
1679  { return _vvminus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1680  INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl)
1681 #if(CXSC_INDEX_CHECK)
1682  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1683 #else
1684  throw()
1685 #endif
1686  { return _vvsminus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1687  INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv)
1688 #if(CXSC_INDEX_CHECK)
1689  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1690 #else
1691  throw()
1692 #endif
1693  { return _vsvminus<l_rvector_slice,l_ivector,l_ivector>(sl,rv); }
1694  INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1695 #if(CXSC_INDEX_CHECK)
1696  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1697 #else
1698  throw()
1699 #endif
1700  { return _vsvsminus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1701 
1702  INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2)
1703 #if(CXSC_INDEX_CHECK)
1704  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1705 #else
1706  throw()
1707 #endif
1708  { return _vvminus<l_ivector,l_rvector,l_ivector>(rv1,rv2); }
1709  INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl)
1710 #if(CXSC_INDEX_CHECK)
1711  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1712 #else
1713  throw()
1714 #endif
1715  { return _vvsminus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1716  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv)
1717 #if(CXSC_INDEX_CHECK)
1718  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1719 #else
1720  throw()
1721 #endif
1722  { return _vsvminus<l_ivector_slice,l_rvector,l_ivector>(sl,rv); }
1723  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1724 #if(CXSC_INDEX_CHECK)
1725  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1726 #else
1727  throw()
1728 #endif
1729  { return _vsvsminus<l_ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
1730 
1731  INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2)
1732 #if(CXSC_INDEX_CHECK)
1733  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1734 #else
1735  throw()
1736 #endif
1737  { return _vvminusassign(rv1,rv2); }
1738  INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl)
1739 #if(CXSC_INDEX_CHECK)
1740  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1741 #else
1742  throw()
1743 #endif
1744  { return _vvsminusassign(rv,sl); }
1746 #if(CXSC_INDEX_CHECK)
1747  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1748 #else
1749  throw()
1750 #endif
1751  { return _vsvminusassign(*this,rv); }
1753 #if(CXSC_INDEX_CHECK)
1754  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1755 #else
1756  throw()
1757 #endif
1758  { return _vsvsminusassign(*this,sl2); }
1759 
1760  INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2)
1761 #if(CXSC_INDEX_CHECK)
1762  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1763 #else
1764  throw()
1765 #endif
1766  { return _vvconv<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1767  INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl)
1768 #if(CXSC_INDEX_CHECK)
1769  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1770 #else
1771  throw()
1772 #endif
1773  { return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1774  INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv)
1775 #if(CXSC_INDEX_CHECK)
1776  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1777 #else
1778  throw()
1779 #endif
1780  { return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1781  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1782 #if(CXSC_INDEX_CHECK)
1783  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1784 #else
1785  throw()
1786 #endif
1787  { return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1788 
1789  INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2)
1790 #if(CXSC_INDEX_CHECK)
1791  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1792 #else
1793  throw()
1794 #endif
1795  { return _vvconv<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1796  INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl)
1797 #if(CXSC_INDEX_CHECK)
1798  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1799 #else
1800  throw()
1801 #endif
1802  { return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1803  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv)
1804 #if(CXSC_INDEX_CHECK)
1805  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1806 #else
1807  throw()
1808 #endif
1809  { return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1810  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1811 #if(CXSC_INDEX_CHECK)
1812  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1813 #else
1814  throw()
1815 #endif
1816  { return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1817 
1818  INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2)
1819 #if(CXSC_INDEX_CHECK)
1820  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1821 #else
1822  throw()
1823 #endif
1824  { return _vvconvassign(rv1,rv2); }
1825  INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl)
1826 #if(CXSC_INDEX_CHECK)
1827  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1828 #else
1829  throw()
1830 #endif
1831  { return _vvsconvassign(rv,sl); }
1833 #if(CXSC_INDEX_CHECK)
1834  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1835 #else
1836  throw()
1837 #endif
1838  { return _vsvconvassign(*this,rv); }
1840 #if(CXSC_INDEX_CHECK)
1841  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1842 #else
1843  throw()
1844 #endif
1845  { return _vsvsconvassign(*this,sl2); }
1846 
1847  INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2)
1848 #if(CXSC_INDEX_CHECK)
1849  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1850 #else
1851  throw()
1852 #endif
1853  { return _vvsect<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1854  INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl)
1855 #if(CXSC_INDEX_CHECK)
1856  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1857 #else
1858  throw()
1859 #endif
1860  { return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1861  INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv)
1862 #if(CXSC_INDEX_CHECK)
1863  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1864 #else
1865  throw()
1866 #endif
1867  { return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1868  INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1869 #if(CXSC_INDEX_CHECK)
1870  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1871 #else
1872  throw()
1873 #endif
1874  { return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1875 
1876  INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2)
1877 #if(CXSC_INDEX_CHECK)
1878  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1879 #else
1880  throw()
1881 #endif
1882  { return _vvsect<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1883  INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl)
1884 #if(CXSC_INDEX_CHECK)
1885  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1886 #else
1887  throw()
1888 #endif
1889  { return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1890  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv)
1891 #if(CXSC_INDEX_CHECK)
1892  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1893 #else
1894  throw()
1895 #endif
1896  { return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1897  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1898 #if(CXSC_INDEX_CHECK)
1899  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1900 #else
1901  throw()
1902 #endif
1903  { return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1904 
1905  INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2)
1906 #if(CXSC_INDEX_CHECK)
1907  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1908 #else
1909  throw()
1910 #endif
1911  { return _vvsectassign(rv1,rv2); }
1912  INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl)
1913 #if(CXSC_INDEX_CHECK)
1914  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1915 #else
1916  throw()
1917 #endif
1918  { return _vvssectassign(rv,sl); }
1920 #if(CXSC_INDEX_CHECK)
1921  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1922 #else
1923  throw()
1924 #endif
1925  { return _vsvsectassign(*this,rv); }
1927 #if(CXSC_INDEX_CHECK)
1928  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1929 #else
1930  throw()
1931 #endif
1932  { return _vsvssectassign(*this,sl2); }
1933 
1934 //-------------------------------- l_interval / interval --------------------------------
1935 
1936  INLINE l_ivector &l_ivector::operator =(const ivector &rv) throw() { return _vvassign<l_ivector,ivector,l_interval>(*this,rv); }
1937  INLINE l_ivector &l_ivector::operator =(const interval &r) throw() { return _vsassign<l_ivector,interval>(*this,r); }
1938  INLINE l_ivector & l_ivector::operator =(const ivector_slice &sl) throw() { return _vvsassign<l_ivector,ivector_slice,l_interval>(*this,sl); }
1940 #if(CXSC_INDEX_CHECK)
1941  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1942 #else
1943  throw()
1944 #endif
1945  { return _vsvassign(*this,rv); }
1946  INLINE l_ivector_slice &l_ivector_slice::operator =(const interval &r) throw() { return _vssassign<l_ivector_slice,interval>(*this,r); }
1948 #if(CXSC_INDEX_CHECK)
1949  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1950 #else
1951  throw()
1952 #endif
1953  { return _vsvsassign(*this,sl); }
1954 
1955  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2)
1956 #if(CXSC_INDEX_CHECK)
1957  throw(OP_WITH_WRONG_DIM)
1958 #else
1959  throw()
1960 #endif
1961  { _vvaccu(dp,rv1,rv2); }
1962  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
1963 #if(CXSC_INDEX_CHECK)
1964  throw(OP_WITH_WRONG_DIM)
1965 #else
1966  throw()
1967 #endif
1968  { _vvaccu(dp,rv2,rv1); }
1969  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv)
1970 #if(CXSC_INDEX_CHECK)
1971  throw(OP_WITH_WRONG_DIM)
1972 #else
1973  throw()
1974 #endif
1975  { _vsvaccu(dp,sl,rv); }
1976  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv)
1977 #if(CXSC_INDEX_CHECK)
1978  throw(OP_WITH_WRONG_DIM)
1979 #else
1980  throw()
1981 #endif
1982  { _vsvaccu(dp,sl,rv); }
1983  INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl)
1984 #if(CXSC_INDEX_CHECK)
1985  throw(OP_WITH_WRONG_DIM)
1986 #else
1987  throw()
1988 #endif
1989  { _vsvaccu(dp,sl,rv); }
1990  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
1991 #if(CXSC_INDEX_CHECK)
1992  throw(OP_WITH_WRONG_DIM)
1993 #else
1994  throw()
1995 #endif
1996  ;
1997  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
1998 #if(CXSC_INDEX_CHECK)
1999  throw(OP_WITH_WRONG_DIM)
2000 #else
2001  throw()
2002 #endif
2003  ;
2004  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl)
2005 #if(CXSC_INDEX_CHECK)
2006  throw(OP_WITH_WRONG_DIM)
2007 #else
2008  throw()
2009 #endif
2010  { _vsvaccu(dp,sl,rv); }
2011  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
2012 #if(CXSC_INDEX_CHECK)
2013  throw(OP_WITH_WRONG_DIM)
2014 #else
2015  throw()
2016 #endif
2017  ;
2018  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
2019 #if(CXSC_INDEX_CHECK)
2020  throw(OP_WITH_WRONG_DIM)
2021 #else
2022  throw()
2023 #endif
2024  ;
2025  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2)
2026 #if(CXSC_INDEX_CHECK)
2027  throw(OP_WITH_WRONG_DIM)
2028 #else
2029  throw()
2030 #endif
2031  { _vsvsaccu(dp,sl2,sl1); }
2032  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2)
2033 #if(CXSC_INDEX_CHECK)
2034  throw(OP_WITH_WRONG_DIM)
2035 #else
2036  throw()
2037 #endif
2038  { _vsvsaccu(dp,sl1,sl2); }
2039 
2040  INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2)
2041 #if(CXSC_INDEX_CHECK)
2042  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2043 #else
2044  throw()
2045 #endif
2046  { return _vvlimult<ivector,l_ivector,l_interval>(rv1,rv2); }
2047  INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
2048 #if(CXSC_INDEX_CHECK)
2049  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2050 #else
2051  throw()
2052 #endif
2053  { return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2054  INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
2055 #if(CXSC_INDEX_CHECK)
2056  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2057 #else
2058  throw()
2059 #endif
2060  { return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2061  INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2)
2062 #if(CXSC_INDEX_CHECK)
2063  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2064 #else
2065  throw()
2066 #endif
2067  { return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
2068 
2069  INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2)
2070 #if(CXSC_INDEX_CHECK)
2071  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2072 #else
2073  throw()
2074 #endif
2075  { return _vvlimult<ivector,l_ivector,l_interval>(rv2,rv1); }
2076  INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
2077 #if(CXSC_INDEX_CHECK)
2078  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2079 #else
2080  throw()
2081 #endif
2082  { return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2083  INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
2084 #if(CXSC_INDEX_CHECK)
2085  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2086 #else
2087  throw()
2088 #endif
2089  { return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2090  INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2)
2091 #if(CXSC_INDEX_CHECK)
2092  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2093 #else
2094  throw()
2095 #endif
2096  { return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
2097 
2098  INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2)
2099 #if(CXSC_INDEX_CHECK)
2100  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2101 #else
2102  throw()
2103 #endif
2104  { return _vvplus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2105  INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
2106 #if(CXSC_INDEX_CHECK)
2107  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2108 #else
2109  throw()
2110 #endif
2111  { return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2112  INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
2113 #if(CXSC_INDEX_CHECK)
2114  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2115 #else
2116  throw()
2117 #endif
2118  { return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2119  INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2)
2120 #if(CXSC_INDEX_CHECK)
2121  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2122 #else
2123  throw()
2124 #endif
2125  { return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2126 
2127  INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2)
2128 #if(CXSC_INDEX_CHECK)
2129  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2130 #else
2131  throw()
2132 #endif
2133  { return _vvplus<ivector,l_ivector,l_ivector>(rv2,rv1); }
2134  INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
2135 #if(CXSC_INDEX_CHECK)
2136  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2137 #else
2138  throw()
2139 #endif
2140  { return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2141  INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
2142 #if(CXSC_INDEX_CHECK)
2143  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2144 #else
2145  throw()
2146 #endif
2147  { return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2148  INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2)
2149 #if(CXSC_INDEX_CHECK)
2150  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2151 #else
2152  throw()
2153 #endif
2154  { return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2155 
2156  INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2)
2157 #if(CXSC_INDEX_CHECK)
2158  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2159 #else
2160  throw()
2161 #endif
2162  { return _vvplusassign(rv1,rv2); }
2164 #if(CXSC_INDEX_CHECK)
2165  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2166 #else
2167  throw()
2168 #endif
2169  { return _vvsplusassign(rv,sl); }
2171 #if(CXSC_INDEX_CHECK)
2172  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2173 #else
2174  throw()
2175 #endif
2176  { return _vsvplusassign(*this,rv); }
2178 #if(CXSC_INDEX_CHECK)
2179  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2180 #else
2181  throw()
2182 #endif
2183  { return _vsvsplusassign(*this,sl2); }
2184 
2185  INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2)
2186 #if(CXSC_INDEX_CHECK)
2187  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2188 #else
2189  throw()
2190 #endif
2191  { return _vvminus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2192  INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
2193 #if(CXSC_INDEX_CHECK)
2194  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2195 #else
2196  throw()
2197 #endif
2198  { return _vvsminus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2199  INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
2200 #if(CXSC_INDEX_CHECK)
2201  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2202 #else
2203  throw()
2204 #endif
2205  { return _vsvminus<ivector_slice,l_ivector,l_ivector>(sl,rv); }
2206  INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2)
2207 #if(CXSC_INDEX_CHECK)
2208  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2209 #else
2210  throw()
2211 #endif
2212  { return _vsvsminus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2213 
2214  INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2)
2215 #if(CXSC_INDEX_CHECK)
2216  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2217 #else
2218  throw()
2219 #endif
2220  { return _vvminus<l_ivector,ivector,l_ivector>(rv1,rv2); }
2221  INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
2222 #if(CXSC_INDEX_CHECK)
2223  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2224 #else
2225  throw()
2226 #endif
2227  { return _vvsminus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2228  INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
2229 #if(CXSC_INDEX_CHECK)
2230  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2231 #else
2232  throw()
2233 #endif
2234  { return _vsvminus<l_ivector_slice,ivector,l_ivector>(sl,rv); }
2235  INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2)
2236 #if(CXSC_INDEX_CHECK)
2237  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2238 #else
2239  throw()
2240 #endif
2241  { return _vsvsminus<l_ivector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2242 
2243  INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2)
2244 #if(CXSC_INDEX_CHECK)
2245  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2246 #else
2247  throw()
2248 #endif
2249  { return _vvminusassign(rv1,rv2); }
2250  INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl)
2251 #if(CXSC_INDEX_CHECK)
2252  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2253 #else
2254  throw()
2255 #endif
2256  { return _vvsminusassign(rv,sl); }
2258 #if(CXSC_INDEX_CHECK)
2259  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2260 #else
2261  throw()
2262 #endif
2263  { return _vsvminusassign(*this,rv); }
2265 #if(CXSC_INDEX_CHECK)
2266  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2267 #else
2268  throw()
2269 #endif
2270  { return _vsvsminusassign(*this,sl2); }
2271 
2272  INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2)
2273 #if(CXSC_INDEX_CHECK)
2274  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2275 #else
2276  throw()
2277 #endif
2278  { return _vvconv<ivector,l_ivector,l_ivector>(rv1,rv2); }
2279  INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
2280 #if(CXSC_INDEX_CHECK)
2281  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2282 #else
2283  throw()
2284 #endif
2285  { return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2286  INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
2287 #if(CXSC_INDEX_CHECK)
2288  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2289 #else
2290  throw()
2291 #endif
2292  { return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2293  INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2)
2294 #if(CXSC_INDEX_CHECK)
2295  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2296 #else
2297  throw()
2298 #endif
2299  { return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2300 
2301  INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2)
2302 #if(CXSC_INDEX_CHECK)
2303  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2304 #else
2305  throw()
2306 #endif
2307  { return _vvconv<ivector,l_ivector,l_ivector>(rv2,rv1); }
2308  INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
2309 #if(CXSC_INDEX_CHECK)
2310  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2311 #else
2312  throw()
2313 #endif
2314  { return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2315  INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
2316 #if(CXSC_INDEX_CHECK)
2317  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2318 #else
2319  throw()
2320 #endif
2321  { return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2322  INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2)
2323 #if(CXSC_INDEX_CHECK)
2324  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2325 #else
2326  throw()
2327 #endif
2328  { return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2329 
2330  INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2)
2331 #if(CXSC_INDEX_CHECK)
2332  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2333 #else
2334  throw()
2335 #endif
2336  { return _vvconvassign(rv1,rv2); }
2337  INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl)
2338 #if(CXSC_INDEX_CHECK)
2339  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2340 #else
2341  throw()
2342 #endif
2343  { return _vvsconvassign(rv,sl); }
2345 #if(CXSC_INDEX_CHECK)
2346  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2347 #else
2348  throw()
2349 #endif
2350  { return _vsvconvassign(*this,rv); }
2352 #if(CXSC_INDEX_CHECK)
2353  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2354 #else
2355  throw()
2356 #endif
2357  { return _vsvsconvassign(*this,sl2); }
2358 
2359  INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2)
2360 #if(CXSC_INDEX_CHECK)
2361  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2362 #else
2363  throw()
2364 #endif
2365  { return _vvsect<ivector,l_ivector,l_ivector>(rv1,rv2); }
2366  INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
2367 #if(CXSC_INDEX_CHECK)
2368  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2369 #else
2370  throw()
2371 #endif
2372  { return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2373  INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
2374 #if(CXSC_INDEX_CHECK)
2375  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2376 #else
2377  throw()
2378 #endif
2379  { return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2380  INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2)
2381 #if(CXSC_INDEX_CHECK)
2382  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2383 #else
2384  throw()
2385 #endif
2386  { return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2387 
2388  INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2)
2389 #if(CXSC_INDEX_CHECK)
2390  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2391 #else
2392  throw()
2393 #endif
2394  { return _vvsect<ivector,l_ivector,l_ivector>(rv2,rv1); }
2395  INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
2396 #if(CXSC_INDEX_CHECK)
2397  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2398 #else
2399  throw()
2400 #endif
2401  { return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2402  INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
2403 #if(CXSC_INDEX_CHECK)
2404  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2405 #else
2406  throw()
2407 #endif
2408  { return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2409  INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2)
2410 #if(CXSC_INDEX_CHECK)
2411  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2412 #else
2413  throw()
2414 #endif
2415  { return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2416 
2417  INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2)
2418 #if(CXSC_INDEX_CHECK)
2419  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2420 #else
2421  throw()
2422 #endif
2423  { return _vvsectassign(rv1,rv2); }
2424  INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl)
2425 #if(CXSC_INDEX_CHECK)
2426  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2427 #else
2428  throw()
2429 #endif
2430  { return _vvssectassign(rv,sl); }
2432 #if(CXSC_INDEX_CHECK)
2433  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2434 #else
2435  throw()
2436 #endif
2437  { return _vsvsectassign(*this,rv); }
2439 #if(CXSC_INDEX_CHECK)
2440  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2441 #else
2442  throw()
2443 #endif
2444  { return _vsvssectassign(*this,sl2); }
2445 
2446 //------------- real x l_real ------------------------
2447  INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2)
2448 #if(CXSC_INDEX_CHECK)
2449  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2450 #else
2451  throw()
2452 #endif
2453  { return _vvconv<rvector,l_rvector,l_ivector>(rv1,rv2); }
2454  INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
2455 #if(CXSC_INDEX_CHECK)
2456  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2457 #else
2458  throw()
2459 #endif
2460  { return _vvconv<rvector,l_rvector,l_ivector>(rv2,rv1); }
2461  INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
2462 #if(CXSC_INDEX_CHECK)
2463  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2464 #else
2465  throw()
2466 #endif
2467  { return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2468  INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
2469 #if(CXSC_INDEX_CHECK)
2470  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2471 #else
2472  throw()
2473 #endif
2474  { return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2475  INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
2476 #if(CXSC_INDEX_CHECK)
2477  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2478 #else
2479  throw()
2480 #endif
2481  { return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2482  INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
2483 #if(CXSC_INDEX_CHECK)
2484  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2485 #else
2486  throw()
2487 #endif
2488  { return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2489  INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2)
2490 #if(CXSC_INDEX_CHECK)
2491  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2492 #else
2493  throw()
2494 #endif
2495  { return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl2,sl1); }
2496  INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2)
2497 #if(CXSC_INDEX_CHECK)
2498  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2499 #else
2500  throw()
2501 #endif
2502  { return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2503 
2504 //------------- l_real x l_real ------------------------
2505  INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2)
2506 #if(CXSC_INDEX_CHECK)
2507  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2508 #else
2509  throw()
2510 #endif
2511  { return _vvconv<l_rvector,l_rvector,l_ivector>(rv2,rv1); }
2512  INLINE l_ivector operator |(const l_rvector &rv, const l_rvector_slice &sl)
2513 #if(CXSC_INDEX_CHECK)
2514  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2515 #else
2516  throw()
2517 #endif
2518  { return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2519  INLINE l_ivector operator |(const l_rvector_slice &sl,const l_rvector &rv)
2520 #if(CXSC_INDEX_CHECK)
2521  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2522 #else
2523  throw()
2524 #endif
2525  { return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2526  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
2527 #if(CXSC_INDEX_CHECK)
2528  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2529 #else
2530  throw()
2531 #endif
2532  { return _vsvsconv<l_rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2533 
2534 //-------------------------------- interval / l_real --------------------------------
2535 
2536 
2537  INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2)
2538 #if(CXSC_INDEX_CHECK)
2539  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2540 #else
2541  throw()
2542 #endif
2543  { return _vvplus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2544  INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
2545 #if(CXSC_INDEX_CHECK)
2546  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2547 #else
2548  throw()
2549 #endif
2550  { return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2551  INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
2552 #if(CXSC_INDEX_CHECK)
2553  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2554 #else
2555  throw()
2556 #endif
2557  { return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2558  INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2)
2559 #if(CXSC_INDEX_CHECK)
2560  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2561 #else
2562  throw()
2563 #endif
2564  { return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2565 
2566  INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2)
2567 #if(CXSC_INDEX_CHECK)
2568  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2569 #else
2570  throw()
2571 #endif
2572  { return _vvplus<l_rvector,ivector,l_ivector>(rv2,rv1); }
2573  INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
2574 #if(CXSC_INDEX_CHECK)
2575  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2576 #else
2577  throw()
2578 #endif
2579  { return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2580  INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
2581 #if(CXSC_INDEX_CHECK)
2582  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2583 #else
2584  throw()
2585 #endif
2586  { return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2587  INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2)
2588 #if(CXSC_INDEX_CHECK)
2589  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2590 #else
2591  throw()
2592 #endif
2593  { return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2594 
2595  INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2)
2596 #if(CXSC_INDEX_CHECK)
2597  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2598 #else
2599  throw()
2600 #endif
2601  { return _vvminus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2602  INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
2603 #if(CXSC_INDEX_CHECK)
2604  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2605 #else
2606  throw()
2607 #endif
2608  { return _vvsminus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2609  INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
2610 #if(CXSC_INDEX_CHECK)
2611  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2612 #else
2613  throw()
2614 #endif
2615  { return _vsvminus<l_rvector_slice,ivector,l_ivector>(sl,rv); }
2616  INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2)
2617 #if(CXSC_INDEX_CHECK)
2618  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2619 #else
2620  throw()
2621 #endif
2622  { return _vsvsminus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2623 
2624  INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2)
2625 #if(CXSC_INDEX_CHECK)
2626  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2627 #else
2628  throw()
2629 #endif
2630  { return _vvminus<ivector,l_rvector,l_ivector>(rv1,rv2); }
2631  INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
2632 #if(CXSC_INDEX_CHECK)
2633  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2634 #else
2635  throw()
2636 #endif
2637  { return _vvsminus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2638  INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
2639 #if(CXSC_INDEX_CHECK)
2640  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2641 #else
2642  throw()
2643 #endif
2644  { return _vsvminus<ivector_slice,l_rvector,l_ivector>(sl,rv); }
2645  INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2)
2646 #if(CXSC_INDEX_CHECK)
2647  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2648 #else
2649  throw()
2650 #endif
2651  { return _vsvsminus<ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2652 
2653  INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2)
2654 #if(CXSC_INDEX_CHECK)
2655  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2656 #else
2657  throw()
2658 #endif
2659  { return _vvconv<l_rvector,ivector,l_ivector>(rv1,rv2); }
2660  INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
2661 #if(CXSC_INDEX_CHECK)
2662  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2663 #else
2664  throw()
2665 #endif
2666  { return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2667  INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
2668 #if(CXSC_INDEX_CHECK)
2669  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2670 #else
2671  throw()
2672 #endif
2673  { return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2674  INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2)
2675 #if(CXSC_INDEX_CHECK)
2676  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2677 #else
2678  throw()
2679 #endif
2680  { return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2681 
2682  INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2)
2683 #if(CXSC_INDEX_CHECK)
2684  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2685 #else
2686  throw()
2687 #endif
2688  { return _vvconv<l_rvector,ivector,l_ivector>(rv2,rv1); }
2689  INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
2690 #if(CXSC_INDEX_CHECK)
2691  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2692 #else
2693  throw()
2694 #endif
2695  { return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2696  INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
2697 #if(CXSC_INDEX_CHECK)
2698  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2699 #else
2700  throw()
2701 #endif
2702  { return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2703  INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2)
2704 #if(CXSC_INDEX_CHECK)
2705  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2706 #else
2707  throw()
2708 #endif
2709  { return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2710 
2711  INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2)
2712 #if(CXSC_INDEX_CHECK)
2713  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2714 #else
2715  throw()
2716 #endif
2717  { return _vvsect<l_rvector,ivector,l_ivector>(rv1,rv2); }
2718  INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
2719 #if(CXSC_INDEX_CHECK)
2720  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2721 #else
2722  throw()
2723 #endif
2724  { return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2725  INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
2726 #if(CXSC_INDEX_CHECK)
2727  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2728 #else
2729  throw()
2730 #endif
2731  { return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2732  INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2)
2733 #if(CXSC_INDEX_CHECK)
2734  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2735 #else
2736  throw()
2737 #endif
2738  { return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2739 
2740  INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2)
2741 #if(CXSC_INDEX_CHECK)
2742  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2743 #else
2744  throw()
2745 #endif
2746  { return _vvsect<l_rvector,ivector,l_ivector>(rv2,rv1); }
2747  INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
2748 #if(CXSC_INDEX_CHECK)
2749  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2750 #else
2751  throw()
2752 #endif
2753  { return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2754  INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
2755 #if(CXSC_INDEX_CHECK)
2756  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2757 #else
2758  throw()
2759 #endif
2760  { return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2761  INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2)
2762 #if(CXSC_INDEX_CHECK)
2763  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2764 #else
2765  throw()
2766 #endif
2767  { return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2768 
2769 } // namespace cxsc
2770 
2771 #endif // _CXSC_LIVECTOR_INL_INCLUDED
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:71
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
The Data Type idotprecision.
Definition: idot.hpp:47
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
l_ivector & operator=(const l_ivector &rv)
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:870
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
l_ivector_slice & operator/=(const l_interval &r)
Implementation of division and allocation operation.
Definition: l_ivector.inl:502
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
The Scalar Type interval.
Definition: interval.hpp:54
l_ivector()
Constructor of class l_ivector.
Definition: l_ivector.inl:31
l_ivector_slice & operator &=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: l_ivector.inl:870
l_ivector_slice & operator *=(const l_interval &r)
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
The Data Type ivector_slice.
Definition: ivector.hpp:962
cimatrix & operator *=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Data Type rvector_slice.
Definition: rvector.hpp:1063
l_interval & operator [](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:141
l_ivector _l_ivector(const l_interval &r)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: l_ivector.inl:252
The Data Type rvector.
Definition: rvector.hpp:57
l_interval()
Constructor of class l_interval.
Definition: l_interval.inl:45
civector operator *(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
The Data Type ivector.
Definition: ivector.hpp:54
l_ivector_slice & operator=(const l_ivector_slice &sl)
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
l_ivector_slice & operator+=(const l_ivector &rv)
Implementation of addition and allocation operation.
Definition: l_ivector.inl:697
l_interval & operator [](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:154
l_ivector & operator()()
Operator for accessing the whole vector.
Definition: l_ivector.hpp:842
l_ivector_slice & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: l_ivector.inl:813
l_ivector_slice & operator()()
Operator for accessing the whole vector.
Definition: l_ivector.hpp:1479
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
The Scalar Type real.
Definition: real.hpp:113
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:744
l_ivector_slice & operator -=(const l_ivector &rv)
Implementation of subtraction and allocation operation.
Definition: l_ivector.inl:756
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737