C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_imatrix.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_imatrix.inl,v 1.20 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIMATRIX_INL_INCLUDED
27 #define _CXSC_LIMATRIX_INL_INCLUDED
28 
29 namespace cxsc {
30 
31 INLINE l_imatrix::l_imatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
32 {
33 }
34 
35 INLINE l_imatrix::l_imatrix(const l_interval &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
36 {
37  dat=new l_interval[1];
38  *dat=r;
39 }
40 
41 INLINE l_imatrix::l_imatrix(const real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
42 {
43  dat=new l_interval[1];
44  *dat=r;
45 }
46 
47 INLINE l_imatrix::l_imatrix(const l_real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
48 {
49  dat=new l_interval[1];
50  *dat=r;
51 }
52 
53 INLINE l_imatrix::l_imatrix(const interval &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
54 {
55  dat=new l_interval[1];
56  *dat=r;
57 }
58 
59 INLINE l_imatrix::l_imatrix(const rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
60 {
61  dat=new l_interval[xsize*ysize];
62  for(int i=0;i<xsize*ysize;i++)
63  dat[i]=rm.dat[i];
64 }
65 
66 INLINE l_imatrix::l_imatrix(const l_rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
67 {
68  dat=new l_interval[xsize*ysize];
69  for(int i=0;i<xsize*ysize;i++)
70  dat[i]=rm.dat[i];
71 }
72 
73 INLINE l_imatrix::l_imatrix(const imatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
74 {
75  dat=new l_interval[xsize*ysize];
76  for(int i=0;i<xsize*ysize;i++)
77  dat[i]=rm.dat[i];
78 }
79 
80 INLINE l_imatrix::l_imatrix(const l_imatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
81 {
82  dat=new l_interval[xsize*ysize];
83  for(int i=0;i<xsize*ysize;i++)
84  dat[i]=rm.dat[i];
85 }
86 
87 INLINE l_imatrix::l_imatrix(const int &m, const int &n)
88 #if(CXSC_INDEX_CHECK)
89  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
90 #else
91  throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
92 #endif
93 {
94 #if(CXSC_INDEX_CHECK)
95  if((n<0)||(m<0)) cxscthrow(ERROR_LIMATRIX_WRONG_BOUNDARIES("l_imatrix::l_imatrix(const int &m, const int &n)"));
96 #endif
97  dat=new l_interval[m*n];
98 }
99 
100 INLINE l_imatrix::l_imatrix(const int &m1, const int &m2, const int &n1, const int &n2)
101 #if(CXSC_INDEX_CHECK)
102  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
103 #else
104  throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
105 #endif
106 {
107 #if(CXSC_INDEX_CHECK)
108  if((m2<m1)||(n2<n1)) cxscthrow(ERROR_LIMATRIX_WRONG_BOUNDARIES("l_imatrix::l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
109 #endif
110  dat=new l_interval[xsize*ysize];
111 }
112 
113 INLINE l_ivector::l_ivector(const l_imatrix_subv &v) throw():l(v.lb),u(v.ub),size(v.size)
114 {
115  dat=new l_interval[size];
116  for (int i=0, j=v.start;i<v.size;i++,j+=v.offset)
117  dat[i]=v.dat[j];
118 }
119 
121 #if(CXSC_INDEX_CHECK)
122 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
123 #else
124 throw()
125 #endif
126 { return _vsvassign(*this,l_ivector(m)); }
127 
128 
129 INLINE l_imatrix::l_imatrix(const l_ivector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
130 {
131  dat=new l_interval[v.size];
132  for(int i=0;i<v.size;i++)
133  dat[i]=v.dat[i];
134 }
135 
136 INLINE l_imatrix::l_imatrix(const rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
137 {
138  dat=new l_interval[v.size];
139  for(int i=0;i<v.size;i++)
140  dat[i]=v.dat[i];
141 }
142 
143 INLINE l_imatrix::l_imatrix(const l_rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
144 {
145  dat=new l_interval[v.size];
146  for(int i=0;i<v.size;i++)
147  dat[i]=v.dat[i];
148 }
149 
150 INLINE l_imatrix::l_imatrix(const ivector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
151 {
152  dat=new l_interval[v.size];
153  for(int i=0;i<v.size;i++)
154  dat[i]=v.dat[i];
155 }
156 
157 INLINE l_imatrix::l_imatrix(const l_ivector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
158 {
159  dat=new l_interval[v.size];
160  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
161  dat[i]=v.dat[j];
162 }
163 
164 INLINE l_imatrix::l_imatrix(const rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
165 {
166  dat=new l_interval[v.size];
167  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
168  dat[i]=v.dat[j];
169 }
170 
171 INLINE l_imatrix::l_imatrix(const ivector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
172 {
173  dat=new l_interval[v.size];
174  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
175  dat[i]=v.dat[j];
176 }
177 
178 INLINE l_imatrix::l_imatrix(const l_rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
179 {
180  dat=new l_interval[v.size];
181  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
182  dat[i]=v.dat[j];
183 }
184 
185  INLINE l_interval &l_imatrix_subv::operator [](const int &i) const
186 #if(CXSC_INDEX_CHECK)
187  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
188 #else
189  throw()
190 #endif
191  {
192 #if(CXSC_INDEX_CHECK)
193  if((i<lb)||(i>ub)) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval &l_imatrix_subv::operator [](const int &i)"));
194 #endif
195  return dat[start+((i-lb)*offset)];
196  }
197 
198  INLINE l_imatrix::l_imatrix(const l_imatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
199  {
200  int i,j;
201 
202  dat=new l_interval[xsize*ysize];
203  for (i=0;i<ysize;i++)
204  {
205  for(j=0;j<xsize;j++)
206  {
207  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
208  }
209  }
210  }
211 
212  INLINE l_imatrix::l_imatrix(const rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
213  {
214  int i,j;
215 
216  dat=new l_interval[xsize*ysize];
217  for (i=0;i<ysize;i++)
218  {
219  for(j=0;j<xsize;j++)
220  {
221  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
222  }
223  }
224  }
225  INLINE l_imatrix::l_imatrix(const l_rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
226  {
227  int i,j;
228 
229  dat=new l_interval[xsize*ysize];
230  for (i=0;i<ysize;i++)
231  {
232  for(j=0;j<xsize;j++)
233  {
234  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
235  }
236  }
237  }
238  INLINE l_imatrix::l_imatrix(const imatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
239  {
240  int i,j;
241 
242  dat=new l_interval[xsize*ysize];
243  for (i=0;i<ysize;i++)
244  {
245  for(j=0;j<xsize;j++)
246  {
247  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
248  }
249  }
250  }
251 
252  INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
253 #if(CXSC_INDEX_CHECK)
254  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
255 #else
256  throw()
257 #endif
258 
259  {
260  return m[i];
261  }
262 
263  INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
264 #if(CXSC_INDEX_CHECK)
265  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
266 #else
267  throw()
268 #endif
269 
270  {
271  return m[Col(i)];
272  }
273 
274  INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
275 #if(CXSC_INDEX_CHECK)
276  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
277 #else
278  throw()
279 #endif
280 
281  {
282  return m[i];
283  }
284 
285  INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
286 #if(CXSC_INDEX_CHECK)
287  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
288 #else
289  throw()
290 #endif
291 
292  {
293  return m[Col(i)];
294  }
295 
296  INLINE l_imatrix_subv l_imatrix::operator [](const int &i) const
297 #if(CXSC_INDEX_CHECK)
298  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
299 #else
300  throw()
301 #endif
302  {
303 #if(CXSC_INDEX_CHECK)
304  if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix::operator [](const int &i)"));
305 #endif
306  return l_imatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
307  }
308 
309  INLINE l_imatrix_subv l_imatrix::operator [](const cxscmatrix_column &i) const
310 #if(CXSC_INDEX_CHECK)
311  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
312 #else
313  throw()
314 #endif
315  {
316 #if(CXSC_INDEX_CHECK)
317  if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix::operator [](const cxscmatrix_column &i)"));
318 #endif
319  return l_imatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
320  }
321 
322  INLINE l_imatrix_slice l_imatrix::operator ()(const int &m, const int &n)
323 #if(CXSC_INDEX_CHECK)
324  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
325 #else
326  throw()
327 #endif
328  {
329 #if(CXSC_INDEX_CHECK)
330  if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix::operator ()(const int &m, const int &n)"));
331 #endif
332  return l_imatrix_slice(*this,1,m,1,n);
333  }
334 
335  INLINE l_imatrix_slice l_imatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
336 #if(CXSC_INDEX_CHECK)
337  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
338 #else
339  throw()
340 #endif
341  {
342 #if(CXSC_INDEX_CHECK)
343  if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
344 #endif
345  return l_imatrix_slice(*this,m1,m2,n1,n2);
346  }
347 
349 #if(CXSC_INDEX_CHECK)
350  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
351 #else
352  throw()
353 #endif
354  {
355 #if(CXSC_INDEX_CHECK)
356  if((i<start1)||(i>end1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix_slice::operator [](const int &i)"));
357 #endif
358  return l_imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
359  }
360 
361  INLINE l_imatrix_subv l_imatrix_slice::operator [](const cxscmatrix_column &i)
362 #if(CXSC_INDEX_CHECK)
363  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
364 #else
365  throw()
366 #endif
367  {
368 #if(CXSC_INDEX_CHECK)
369  if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix_slice::operator [](const cxscmatrix_column &i)"));
370 #endif
371  return l_imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
372  }
373 
374  INLINE l_imatrix_slice l_imatrix_slice::operator ()(const int &m, const int &n)
375 #if(CXSC_INDEX_CHECK)
376  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
377 #else
378  throw()
379 #endif
380  {
381 #if(CXSC_INDEX_CHECK)
382  if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix_slice::operator ()(const int &m, const int &n)"));
383 #endif
384  return l_imatrix_slice(*this,1,m,1,n);
385  }
386 
387  INLINE l_imatrix_slice l_imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
388 #if(CXSC_INDEX_CHECK)
389  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
390 #else
391  throw()
392 #endif
393  {
394 #if(CXSC_INDEX_CHECK)
395  if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
396 #endif
397  return l_imatrix_slice(*this,m1,m2,n1,n2);
398  }
399 
401 #if(CXSC_INDEX_CHECK)
402  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
403 #else
404  throw()
405 #endif
406 {
407 #if(CXSC_INDEX_CHECK)
408  if(1<lb||i>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_imatrix_subv l_imatrix_subv::operator ()(const int &i)"));
409 #endif
410  return l_imatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
411 }
412 
413 INLINE l_imatrix_subv l_imatrix_subv::operator ()(const int &i1,const int &i2)
414 #if(CXSC_INDEX_CHECK)
415  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
416 #else
417  throw()
418 #endif
419 {
420 #if(CXSC_INDEX_CHECK)
421  if(i1<lb||i2>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_imatrix_subv l_imatrix_subv::operator ()(const int &i1,const int &i2)"));
422 #endif
423  return l_imatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
424 }
425 
426 
427 
428  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_imatrix_subv &rv) throw() { return _mvmvassign(*this,rv); }
429  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_interval &r) throw() { return _mvsassign(*this,r); }
431 #if(CXSC_INDEX_CHECK)
432  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
433 #else
434  throw()
435 #endif
436  { return _mvvassign(*this,v); }
438 #if(CXSC_INDEX_CHECK)
439  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
440 #else
441  throw()
442 #endif
443  { return _mvvassign(*this,l_ivector(v)); }
444 
445  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvvassign(*this,rvector(rv)); }
446  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); }
448 #if(CXSC_INDEX_CHECK)
449  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
450 #else
451  throw()
452 #endif
453  { return _mvvassign(*this,v); }
455 #if(CXSC_INDEX_CHECK)
456  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
457 #else
458  throw()
459 #endif
460  { return _mvvassign(*this,l_ivector(v)); }
461 
462  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rmatrix_subv &rv) throw() { return _mvvassign(*this,l_rvector(rv)); }
463  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_real &r) throw() { return _mvsassign(*this,r); }
465 #if(CXSC_INDEX_CHECK)
466  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
467 #else
468  throw()
469 #endif
470  { return _mvvassign(*this,v); }
472 #if(CXSC_INDEX_CHECK)
473  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
474 #else
475  throw()
476 #endif
477  { return _mvvassign(*this,l_ivector(v)); }
478 
479  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const imatrix_subv &rv) throw() { return _mvvassign(*this,ivector(rv)); }
480  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const interval &r) throw() { return _mvsassign(*this,r); }
482 #if(CXSC_INDEX_CHECK)
483  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
484 #else
485  throw()
486 #endif
487  { return _mvvassign(*this,v); }
489 #if(CXSC_INDEX_CHECK)
490  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
491 #else
492  throw()
493 #endif
494  { return _mvvassign(*this,l_ivector(v)); }
495 
496  INLINE l_imatrix &l_imatrix::operator =(const l_interval &r) throw() { return _msassign(*this,r); }
497  INLINE l_imatrix &l_imatrix::operator =(const l_imatrix &m) throw() { return _mmassign<l_imatrix,l_imatrix,l_interval>(*this,m, l_interval()); }
498  INLINE l_imatrix &l_imatrix::operator =(const l_imatrix_slice &ms) throw() { return _mmsassign<l_imatrix,l_imatrix_slice,l_interval>(*this,ms); }
499  INLINE l_imatrix &l_imatrix::operator =(const l_ivector &v) throw() { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,v); }
500  INLINE l_imatrix &l_imatrix::operator =(const l_ivector_slice &v) throw() { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,l_ivector(v)); }
501 
502  INLINE l_imatrix &l_imatrix::operator =(const real &r) throw() { return _msassign(*this,l_interval(r)); }
503  INLINE l_imatrix &l_imatrix::operator =(const rmatrix &m) throw() { return _mmassign<l_imatrix,rmatrix,l_interval>(*this,m, l_interval()); }
504  INLINE l_imatrix &l_imatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<l_imatrix,rmatrix_slice,l_interval>(*this,ms); }
505  INLINE l_imatrix &l_imatrix::operator =(const rvector &v) throw() { return _mvassign<l_imatrix,rvector,l_interval>(*this,v); }
506  INLINE l_imatrix &l_imatrix::operator =(const rvector_slice &v) throw() { return _mvassign<l_imatrix,rvector,l_interval>(*this,rvector(v)); }
507 
508  INLINE l_imatrix &l_imatrix::operator =(const l_real &r) throw() { return _msassign(*this,l_interval(r)); }
509  INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix &m) throw() { return _mmassign<l_imatrix,l_rmatrix,l_interval>(*this,m, l_interval()); }
510  INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix_slice &ms) throw() { return _mmsassign<l_imatrix,l_rmatrix_slice,l_interval>(*this,ms); }
511  INLINE l_imatrix &l_imatrix::operator =(const l_rvector &v) throw() { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,v); }
512  INLINE l_imatrix &l_imatrix::operator =(const l_rvector_slice &v) throw() { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,l_rvector(v)); }
513 
514  INLINE l_imatrix &l_imatrix::operator =(const interval &r) throw() { return _msassign(*this,l_interval(r)); }
515  INLINE l_imatrix &l_imatrix::operator =(const imatrix &m) throw() { return _mmassign<l_imatrix,imatrix,l_interval>(*this,m, l_interval()); }
516  INLINE l_imatrix &l_imatrix::operator =(const imatrix_slice &ms) throw() { return _mmsassign<l_imatrix,imatrix_slice,l_interval>(*this,ms); }
517  INLINE l_imatrix &l_imatrix::operator =(const ivector &v) throw() { return _mvassign<l_imatrix,ivector,l_interval>(*this,v); }
518  INLINE l_imatrix &l_imatrix::operator =(const ivector_slice &v) throw() { return _mvassign<l_imatrix,ivector,l_interval>(*this,ivector(v)); }
519 
520  INLINE l_imatrix::operator void*() throw() { return _mvoid(*this); }
521 
523 #if(CXSC_INDEX_CHECK)
524  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
525 #else
526  throw()
527 #endif
528  { return _msmassign(*this,m); }
530 #if(CXSC_INDEX_CHECK)
531  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
532 #else
533  throw()
534 #endif
535  { return _msmsassign(*this,ms); }
536  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_interval &r) throw() { return _mssassign(*this,r); }
538 #if(CXSC_INDEX_CHECK)
539  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
540 #else
541  throw()
542 #endif
543  { return _msmassign(*this,l_imatrix(v)); }
545 #if(CXSC_INDEX_CHECK)
546  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
547 #else
548  throw()
549 #endif
550  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
552 #if(CXSC_INDEX_CHECK)
553  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
554 #else
555  throw()
556 #endif
557  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
558 
560 #if(CXSC_INDEX_CHECK)
561  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
562 #else
563  throw()
564 #endif
565  { return _msmassign(*this,m); }
567 #if(CXSC_INDEX_CHECK)
568  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
569 #else
570  throw()
571 #endif
572  { return _msmsassign(*this,ms); }
573  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); }
575 #if(CXSC_INDEX_CHECK)
576  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
577 #else
578  throw()
579 #endif
580  { return _msmassign(*this,l_imatrix(v)); }
582 #if(CXSC_INDEX_CHECK)
583  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
584 #else
585  throw()
586 #endif
587  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
589 #if(CXSC_INDEX_CHECK)
590  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
591 #else
592  throw()
593 #endif
594  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
595 
597 #if(CXSC_INDEX_CHECK)
598  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
599 #else
600  throw()
601 #endif
602  { return _msmassign(*this,m); }
604 #if(CXSC_INDEX_CHECK)
605  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
606 #else
607  throw()
608 #endif
609  { return _msmsassign(*this,ms); }
610  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_real &r) throw() { return _mssassign(*this,r); }
612 #if(CXSC_INDEX_CHECK)
613  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
614 #else
615  throw()
616 #endif
617  { return _msmassign(*this,l_imatrix(v)); }
619 #if(CXSC_INDEX_CHECK)
620  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
621 #else
622  throw()
623 #endif
624  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
626 #if(CXSC_INDEX_CHECK)
627  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
628 #else
629  throw()
630 #endif
631  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
632 
634 #if(CXSC_INDEX_CHECK)
635  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
636 #else
637  throw()
638 #endif
639  { return _msmassign(*this,m); }
641 #if(CXSC_INDEX_CHECK)
642  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
643 #else
644  throw()
645 #endif
646  { return _msmsassign(*this,ms); }
647  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const interval &r) throw() { return _mssassign(*this,r); }
649 #if(CXSC_INDEX_CHECK)
650  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
651 #else
652  throw()
653 #endif
654  { return _msmassign(*this,l_imatrix(v)); }
656 #if(CXSC_INDEX_CHECK)
657  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
658 #else
659  throw()
660 #endif
661  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
663 #if(CXSC_INDEX_CHECK)
664  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
665 #else
666  throw()
667 #endif
668  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
669 
670  INLINE l_imatrix_slice::operator void*() throw() { return _msvoid(*this); }
671  INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) throw() { return _mvsdiv<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
672  INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) throw() { return _mvsmult<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
673  INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) throw() { return _mvsmult<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
674  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_interval &c) throw() { return _mvsmultassign(*this,c); }
675  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_interval &c) throw() { return _mvsplusassign(*this,c); }
676  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_interval &c) throw() { return _mvsminusassign(*this,c); }
677  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_interval &c) throw() { return _mvsdivassign(*this,c); }
678  INLINE l_ivector abs(const l_imatrix_subv &mv) throw() { return _mvabs<l_imatrix_subv,l_ivector>(mv); }
679  INLINE l_rvector diam(const l_imatrix_subv &mv) throw() { return _mvdiam<l_imatrix_subv,l_rvector>(mv); }
680  INLINE l_rvector mid(const l_imatrix_subv &mv) throw() { return _mvmid<l_imatrix_subv,l_rvector>(mv); }
681  INLINE l_rvector Inf(const l_imatrix_subv &mv) throw() { return _mvinf<l_imatrix_subv,l_rvector>(mv); }
682  INLINE l_rvector Sup(const l_imatrix_subv &mv) throw() { return _mvsup<l_imatrix_subv,l_rvector>(mv); }
683 
684  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
685 #if(CXSC_INDEX_CHECK)
686  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
687 #else
688  throw()
689 #endif
690  { return _mvvsetinf(iv,rv); }
691  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
692 #if(CXSC_INDEX_CHECK)
693  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
694 #else
695  throw()
696 #endif
697  { return _mvvsetsup(iv,rv); }
698  INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
699 #if(CXSC_INDEX_CHECK)
700  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
701 #else
702  throw()
703 #endif
704  { return _mvvusetinf(iv,rv); }
705  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
706 #if(CXSC_INDEX_CHECK)
707  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
708 #else
709  throw()
710 #endif
711  { return _mvvusetsup(iv,rv); }
712  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) throw() { return _mvssetsup(iv,r); }
713  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) throw() { return _mvssetinf(iv,r); }
714  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) throw() { return _mvsusetsup(iv,r); }
715  INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) throw() { return _mvsusetinf(iv,r); }
716  INLINE l_ivector &l_ivector::operator =(const l_imatrix_subv &mv) throw() { return _vmvassign<l_ivector,l_imatrix_subv,l_interval>(*this,mv); }
717  INLINE l_ivector_slice &l_ivector_slice::operator =(const l_imatrix_subv &mv) throw() { return _vsvassign(*this,l_ivector(mv)); }
718 
719  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
720 #if(CXSC_INDEX_CHECK)
721  throw(OP_WITH_WRONG_DIM)
722 #else
723  throw()
724 #endif
725  { _mvmvaccu(dp,rv1,rv2); }
726  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
727 #if(CXSC_INDEX_CHECK)
728  throw(OP_WITH_WRONG_DIM)
729 #else
730  throw()
731 #endif
732  { _vmvaccu(dp,rv1,rv2); }
733  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
734 #if(CXSC_INDEX_CHECK)
735  throw(OP_WITH_WRONG_DIM)
736 #else
737  throw()
738 #endif
739  { _vmvaccu(dp,rv2,rv1); }
740  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
741 #if(CXSC_INDEX_CHECK)
742  throw(OP_WITH_WRONG_DIM)
743 #else
744  throw()
745 #endif
746  { _vmvaccu(dp,l_ivector(sl1),rv2); }
747  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
748 #if(CXSC_INDEX_CHECK)
749  throw(OP_WITH_WRONG_DIM)
750 #else
751  throw()
752 #endif
753  { _vmvaccu(dp,l_ivector(sl2),rv1); }
754 
755  INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
756 #if(CXSC_INDEX_CHECK)
757  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
758 #else
759  throw()
760 #endif
761  { return _mvmvlimult<l_imatrix_subv,l_imatrix_subv,l_interval>(rv1,rv2); }
762  INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
763 #if(CXSC_INDEX_CHECK)
764  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
765 #else
766  throw()
767 #endif
768  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv1,rv2); }
769  INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
770 #if(CXSC_INDEX_CHECK)
771  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
772 #else
773  throw()
774 #endif
775  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv2,rv1); }
777 #if(CXSC_INDEX_CHECK)
778  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
779 #else
780  throw()
781 #endif
782  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(l_ivector(sl),sv); }
784 #if(CXSC_INDEX_CHECK)
785  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
786 #else
787  throw()
788 #endif
789  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(l_ivector(vs),mv); }
790  INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
791 #if(CXSC_INDEX_CHECK)
792  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
793 #else
794  throw()
795 #endif
796  { return _mvmvplus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
797  INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
798 #if(CXSC_INDEX_CHECK)
799  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
800 #else
801  throw()
802 #endif
803  { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
804  INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
805 #if(CXSC_INDEX_CHECK)
806  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
807 #else
808  throw()
809 #endif
810  { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
811  INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
812 #if(CXSC_INDEX_CHECK)
813  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
814 #else
815  throw()
816 #endif
817  { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
818  INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
819 #if(CXSC_INDEX_CHECK)
820  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
821 #else
822  throw()
823 #endif
824  { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
826 #if(CXSC_INDEX_CHECK)
827  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
828 #else
829  throw()
830 #endif
831  { return _mvvplusassign(*this,rv); }
833 #if(CXSC_INDEX_CHECK)
834  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
835 #else
836  throw()
837 #endif
838  { return _mvvplusassign(*this,l_ivector(rv)); }
839  INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
840 #if(CXSC_INDEX_CHECK)
841  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
842 #else
843  throw()
844 #endif
845  { return _mvmvminus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
846  INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
847 #if(CXSC_INDEX_CHECK)
848  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
849 #else
850  throw()
851 #endif
852  { return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(rv1,rv2); }
853  INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
854 #if(CXSC_INDEX_CHECK)
855  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
856 #else
857  throw()
858 #endif
859  { return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
860  INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
861 #if(CXSC_INDEX_CHECK)
862  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
863 #else
864  throw()
865 #endif
866  { return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(l_ivector(sl),mv); }
867  INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
868 #if(CXSC_INDEX_CHECK)
869  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
870 #else
871  throw()
872 #endif
873  { return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
875 #if(CXSC_INDEX_CHECK)
876  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
877 #else
878  throw()
879 #endif
880  { return _mvvminusassign(*this,rv); }
882 #if(CXSC_INDEX_CHECK)
883  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
884 #else
885  throw()
886 #endif
887  { return _mvvminusassign(*this,l_ivector(rv)); }
888  INLINE l_ivector operator |(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
889 #if(CXSC_INDEX_CHECK)
890  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
891 #else
892  throw()
893 #endif
894  { return _mvmvconv<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
895  INLINE l_ivector operator |(const l_imatrix_subv &rv1,const l_ivector &rv2)
896 #if(CXSC_INDEX_CHECK)
897  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
898 #else
899  throw()
900 #endif
901  { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
902  INLINE l_ivector operator |(const l_ivector & rv1, const l_imatrix_subv &rv2)
903 #if(CXSC_INDEX_CHECK)
904  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
905 #else
906  throw()
907 #endif
908  { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
909  INLINE l_ivector operator |(const l_ivector_slice &sl,const l_imatrix_subv &mv)
910 #if(CXSC_INDEX_CHECK)
911  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
912 #else
913  throw()
914 #endif
915  { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
916  INLINE l_ivector operator |(const l_imatrix_subv &mv,const l_ivector_slice &sl)
917 #if(CXSC_INDEX_CHECK)
918  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
919 #else
920  throw()
921 #endif
922  { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
924 #if(CXSC_INDEX_CHECK)
925  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
926 #else
927  throw()
928 #endif
929  { return _mvvconvassign(*this,rv); }
931 #if(CXSC_INDEX_CHECK)
932  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
933 #else
934  throw()
935 #endif
936  { return _mvvconvassign(*this,l_ivector(rv)); }
937  INLINE l_ivector operator &(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
938 #if(CXSC_INDEX_CHECK)
939  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
940 #else
941  throw()
942 #endif
943  { return _mvmvsect<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
944  INLINE l_ivector operator &(const l_imatrix_subv &rv1,const l_ivector &rv2)
945 #if(CXSC_INDEX_CHECK)
946  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
947 #else
948  throw()
949 #endif
950  { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
951  INLINE l_ivector operator &(const l_ivector & rv1, const l_imatrix_subv &rv2)
952 #if(CXSC_INDEX_CHECK)
953  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
954 #else
955  throw()
956 #endif
957  { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
958  INLINE l_ivector operator &(const l_ivector_slice &sl,const l_imatrix_subv &mv)
959 #if(CXSC_INDEX_CHECK)
960  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
961 #else
962  throw()
963 #endif
964  { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
965  INLINE l_ivector operator &(const l_imatrix_subv &mv,const l_ivector_slice &sl)
966 #if(CXSC_INDEX_CHECK)
967  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
968 #else
969  throw()
970 #endif
971  { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
973 #if(CXSC_INDEX_CHECK)
974  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
975 #else
976  throw()
977 #endif
978  { return _mvvsectassign(*this,rv); }
980 #if(CXSC_INDEX_CHECK)
981  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
982 #else
983  throw()
984 #endif
985  { return _mvvsectassign(*this,l_ivector(rv)); }
986 
987 // real
988  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
989 #if(CXSC_INDEX_CHECK)
990  throw(OP_WITH_WRONG_DIM)
991 #else
992  throw()
993 #endif
994  { _mvmvaccu(dp,rv2,rv1); }
995  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
996 #if(CXSC_INDEX_CHECK)
997  throw(OP_WITH_WRONG_DIM)
998 #else
999  throw()
1000 #endif
1001  { _vmvaccu(dp,rvector(sl2),rv1); }
1002  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
1003 #if(CXSC_INDEX_CHECK)
1004  throw(OP_WITH_WRONG_DIM)
1005 #else
1006  throw()
1007 #endif
1008  { _vmvaccu(dp,rv2,rv1); }
1009  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
1010 #if(CXSC_INDEX_CHECK)
1011  throw(OP_WITH_WRONG_DIM)
1012 #else
1013  throw()
1014 #endif
1015  { _mvmvaccu(dp,rv1,rv2); }
1016  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
1017 #if(CXSC_INDEX_CHECK)
1018  throw(OP_WITH_WRONG_DIM)
1019 #else
1020  throw()
1021 #endif
1022  { _vmvaccu(dp,rvector(sl1),rv2); }
1023  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
1024 #if(CXSC_INDEX_CHECK)
1025  throw(OP_WITH_WRONG_DIM)
1026 #else
1027  throw()
1028 #endif
1029  { _vmvaccu(dp,rv1,rv2); }
1030 // l_real
1031  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
1032 #if(CXSC_INDEX_CHECK)
1033  throw(OP_WITH_WRONG_DIM)
1034 #else
1035  throw()
1036 #endif
1037  { _mvmvaccu(dp,rv2,rv1); }
1038  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
1039 #if(CXSC_INDEX_CHECK)
1040  throw(OP_WITH_WRONG_DIM)
1041 #else
1042  throw()
1043 #endif
1044  { _vmvaccu(dp,l_rvector(sl2),rv1); }
1045  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
1046 #if(CXSC_INDEX_CHECK)
1047  throw(OP_WITH_WRONG_DIM)
1048 #else
1049  throw()
1050 #endif
1051  { _vmvaccu(dp,rv2,rv1); }
1052  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
1053 #if(CXSC_INDEX_CHECK)
1054  throw(OP_WITH_WRONG_DIM)
1055 #else
1056  throw()
1057 #endif
1058  { _mvmvaccu(dp,rv1,rv2); }
1059  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
1060 #if(CXSC_INDEX_CHECK)
1061  throw(OP_WITH_WRONG_DIM)
1062 #else
1063  throw()
1064 #endif
1065  { _vmvaccu(dp,l_rvector(sl1),rv2); }
1066  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
1067 #if(CXSC_INDEX_CHECK)
1068  throw(OP_WITH_WRONG_DIM)
1069 #else
1070  throw()
1071 #endif
1072  { _vmvaccu(dp,rv1,rv2); }
1073 // interval
1074  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
1075 #if(CXSC_INDEX_CHECK)
1076  throw(OP_WITH_WRONG_DIM)
1077 #else
1078  throw()
1079 #endif
1080  { _mvmvaccu(dp,rv2,rv1); }
1081  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
1082 #if(CXSC_INDEX_CHECK)
1083  throw(OP_WITH_WRONG_DIM)
1084 #else
1085  throw()
1086 #endif
1087  { _vmvaccu(dp,ivector(sl2),rv1); }
1088  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
1089 #if(CXSC_INDEX_CHECK)
1090  throw(OP_WITH_WRONG_DIM)
1091 #else
1092  throw()
1093 #endif
1094  { _vmvaccu(dp,rv2,rv1); }
1095  INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
1096 #if(CXSC_INDEX_CHECK)
1097  throw(OP_WITH_WRONG_DIM)
1098 #else
1099  throw()
1100 #endif
1101  { _mvmvaccu(dp,rv1,rv2); }
1102  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
1103 #if(CXSC_INDEX_CHECK)
1104  throw(OP_WITH_WRONG_DIM)
1105 #else
1106  throw()
1107 #endif
1108  { _vmvaccu(dp,ivector(sl1),rv2); }
1109  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
1110 #if(CXSC_INDEX_CHECK)
1111  throw(OP_WITH_WRONG_DIM)
1112 #else
1113  throw()
1114 #endif
1115  { _vmvaccu(dp,rv1,rv2); }
1116 
1117 
1118 
1119 // matrix x matrix
1125  INLINE l_imatrix _imatrix(const l_imatrix &rm) throw() { return rm; }
1131  INLINE l_imatrix _imatrix(const l_ivector &v) throw() { return l_imatrix(v); }
1137  INLINE l_imatrix _imatrix(const l_ivector_slice &v) throw() { return l_imatrix(v); }
1143  INLINE l_imatrix _imatrix(const l_interval &r) throw() { return l_imatrix(r); }
1144  INLINE int Lb(const l_imatrix &rm, const int &i)
1145 #if(CXSC_INDEX_CHECK)
1146  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1147 #else
1148  throw()
1149 #endif
1150  { return _mlb(rm,i); }
1151  INLINE int Ub(const l_imatrix &rm, const int &i)
1152 #if(CXSC_INDEX_CHECK)
1153  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1154 #else
1155  throw()
1156 #endif
1157  { return _mub(rm,i); }
1158  INLINE int Lb(const l_imatrix_slice &rm, const int &i)
1159 #if(CXSC_INDEX_CHECK)
1160  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1161 #else
1162  throw()
1163 #endif
1164  { return _mslb(rm,i); }
1165  INLINE int Ub(const l_imatrix_slice &rm, const int &i)
1166 #if(CXSC_INDEX_CHECK)
1167  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1168 #else
1169  throw()
1170 #endif
1171  { return _msub(rm,i); }
1172  INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
1173 #if(CXSC_INDEX_CHECK)
1174  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1175 #else
1176  throw()
1177 #endif
1178  { return _msetlb(m,i,j); }
1179  INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
1180 #if(CXSC_INDEX_CHECK)
1181  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1182 #else
1183  throw()
1184 #endif
1185  { return _msetub(m,i,j); }
1186 
1187 
1188  INLINE int RowLen ( const l_imatrix& A ) // Length of the rows of a l_interval matrix
1189  { return Ub(A,2)-Lb(A,2)+1; } //------------------------------------------
1190 
1191  INLINE int ColLen ( const l_imatrix& A ) // Length of the columns of a l_interval matrix
1192  { return Ub(A,1)-Lb(A,1)+1; } //---------------------------------------------
1193 
1194  INLINE int RowLen ( const l_imatrix_slice& A ) // Length of the rows of a l_interval matrix
1195  { return Ub(A,2)-Lb(A,2)+1; } //------------------------------------------
1196 
1197  INLINE int ColLen ( const l_imatrix_slice& A ) // Length of the columns of a l_interval matrix
1198  { return Ub(A,1)-Lb(A,1)+1; } //---------------------------------------------
1199 
1200  INLINE void Resize(l_imatrix &A) throw() { _mresize(A);}
1201  INLINE void Resize(l_imatrix &A,const int &m, const int &n)
1202 #if(CXSC_INDEX_CHECK)
1203  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
1204 #else
1205  throw()
1206 #endif
1207  { _mresize<l_imatrix,l_interval>(A,m,n); }
1208  INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
1209 #if(CXSC_INDEX_CHECK)
1210  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
1211 #else
1212  throw()
1213 #endif
1214  { _mresize<l_imatrix,l_interval>(A,m1,m2,n1,n2); }
1215  INLINE l_imatrix abs(const l_imatrix &m) throw() { return _mabs<l_imatrix,l_imatrix>(m); }
1216  INLINE l_imatrix abs(const l_imatrix_slice &ms) throw() { return _msabs<l_imatrix_slice,l_imatrix>(ms); }
1217  INLINE l_rmatrix diam(const l_imatrix &m) throw() { return _mdiam<l_imatrix,l_rmatrix>(m); }
1218  INLINE l_rmatrix diam(const l_imatrix_slice &m) throw() { return _msdiam<l_imatrix_slice,l_rmatrix>(m); }
1219  INLINE l_rmatrix mid(const l_imatrix &m) throw() { return _mmid<l_imatrix,l_rmatrix>(m); }
1220  INLINE l_rmatrix mid(const l_imatrix_slice &m) throw() { return _msmid<l_imatrix_slice,l_rmatrix>(m); }
1221  INLINE l_rmatrix Inf(const l_imatrix &m) throw() { return _minf<l_imatrix,l_rmatrix>(m); }
1222  INLINE l_rmatrix Sup(const l_imatrix &m) throw() { return _msup<l_imatrix,l_rmatrix>(m); }
1223  INLINE l_rmatrix Inf(const l_imatrix_slice &m) throw() { return _msinf<l_imatrix_slice,l_rmatrix>(m); }
1224  INLINE l_rmatrix Sup(const l_imatrix_slice &m) throw() { return _mssup<l_imatrix_slice,l_rmatrix>(m); }
1225  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
1226 #if(CXSC_INDEX_CHECK)
1227  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1228 #else
1229  throw()
1230 #endif
1231  { return _mmsetinf<l_imatrix,l_rmatrix>(cm,rm); }
1232  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
1233 #if(CXSC_INDEX_CHECK)
1234  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1235 #else
1236  throw()
1237 #endif
1238  { return _msmsetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1239  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
1240 #if(CXSC_INDEX_CHECK)
1241  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1242 #else
1243  throw()
1244 #endif
1245  { return _mmssetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1246  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
1247 #if(CXSC_INDEX_CHECK)
1248  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1249 #else
1250  throw()
1251 #endif
1252  { return _msmssetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1253  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
1254 #if(CXSC_INDEX_CHECK)
1255  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1256 #else
1257  throw()
1258 #endif
1259  { return _mmsetsup<l_imatrix,l_rmatrix>(cm,rm); }
1260  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
1261 #if(CXSC_INDEX_CHECK)
1262  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1263 #else
1264  throw()
1265 #endif
1266  { return _msmsetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1267  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
1268 #if(CXSC_INDEX_CHECK)
1269  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1270 #else
1271  throw()
1272 #endif
1273  { return _mmssetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1274  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
1275 #if(CXSC_INDEX_CHECK)
1276  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1277 #else
1278  throw()
1279 #endif
1280  { return _msmssetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1281  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
1282 #if(CXSC_INDEX_CHECK)
1283  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1284 #else
1285  throw()
1286 #endif
1287  { return _mmusetinf<l_imatrix,l_rmatrix>(cm,rm); }
1288  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
1289 #if(CXSC_INDEX_CHECK)
1290  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1291 #else
1292  throw()
1293 #endif
1294  { return _msmusetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1295  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
1296 #if(CXSC_INDEX_CHECK)
1297  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1298 #else
1299  throw()
1300 #endif
1301  { return _mmsusetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1302  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
1303 #if(CXSC_INDEX_CHECK)
1304  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1305 #else
1306  throw()
1307 #endif
1308  { return _msmsusetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1309  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
1310 #if(CXSC_INDEX_CHECK)
1311  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1312 #else
1313  throw()
1314 #endif
1315  { return _mmusetsup<l_imatrix,l_rmatrix>(cm,rm); }
1316  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
1317 #if(CXSC_INDEX_CHECK)
1318  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1319 #else
1320  throw()
1321 #endif
1322  { return _msmusetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1323  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
1324 #if(CXSC_INDEX_CHECK)
1325  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1326 #else
1327  throw()
1328 #endif
1329  { return _mmsusetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1330  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
1331 #if(CXSC_INDEX_CHECK)
1332  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1333 #else
1334  throw()
1335 #endif
1336  { return _msmsusetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1338 #if(CXSC_INDEX_CHECK)
1339  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ)
1340 #else
1341  throw()
1342 #endif
1343  { _smconstr(*this,m); }
1344 // INLINE l_interval l_interval::_interval(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
1345 
1346  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const real &c) throw() { return _mvsmultassign(*this,c); }
1347  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const real &c) throw() { return _mvsplusassign(*this,c); }
1348  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const real &c) throw() { return _mvsminusassign(*this,c); }
1349  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const real &c) throw() { return _mvsdivassign(*this,c); }
1351 #if(CXSC_INDEX_CHECK)
1352  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1353 #else
1354  throw()
1355 #endif
1356  { return _mvvplusassign(*this,rv); }
1358 #if(CXSC_INDEX_CHECK)
1359  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1360 #else
1361  throw()
1362 #endif
1363  { return _mvvplusassign(*this,rvector(rv)); }
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1367 #else
1368  throw()
1369 #endif
1370  { return _mvvminusassign(*this,rv); }
1372 #if(CXSC_INDEX_CHECK)
1373  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1374 #else
1375  throw()
1376 #endif
1377  { return _mvvminusassign(*this,rvector(rv)); }
1379 #if(CXSC_INDEX_CHECK)
1380  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1381 #else
1382  throw()
1383 #endif
1384  { return _mvvconvassign(*this,rv); }
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1388 #else
1389  throw()
1390 #endif
1391  { return _mvvconvassign(*this,rvector(rv)); }
1393 #if(CXSC_INDEX_CHECK)
1394  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1395 #else
1396  throw()
1397 #endif
1398  { return _mvvsectassign(*this,rv); }
1400 #if(CXSC_INDEX_CHECK)
1401  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1402 #else
1403  throw()
1404 #endif
1405  { return _mvvsectassign(*this,rvector(rv)); }
1406 
1407  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_real &c) throw() { return _mvsmultassign(*this,c); }
1408  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_real &c) throw() { return _mvsplusassign(*this,c); }
1409  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_real &c) throw() { return _mvsminusassign(*this,c); }
1410  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_real &c) throw() { return _mvsdivassign(*this,c); }
1412 #if(CXSC_INDEX_CHECK)
1413  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1414 #else
1415  throw()
1416 #endif
1417  { return _mvvplusassign(*this,rv); }
1419 #if(CXSC_INDEX_CHECK)
1420  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1421 #else
1422  throw()
1423 #endif
1424  { return _mvvplusassign(*this,l_rvector(rv)); }
1426 #if(CXSC_INDEX_CHECK)
1427  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1428 #else
1429  throw()
1430 #endif
1431  { return _mvvminusassign(*this,rv); }
1433 #if(CXSC_INDEX_CHECK)
1434  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1435 #else
1436  throw()
1437 #endif
1438  { return _mvvminusassign(*this,l_rvector(rv)); }
1440 #if(CXSC_INDEX_CHECK)
1441  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1442 #else
1443  throw()
1444 #endif
1445  { return _mvvconvassign(*this,rv); }
1447 #if(CXSC_INDEX_CHECK)
1448  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1449 #else
1450  throw()
1451 #endif
1452  { return _mvvconvassign(*this,l_rvector(rv)); }
1454 #if(CXSC_INDEX_CHECK)
1455  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1456 #else
1457  throw()
1458 #endif
1459  { return _mvvsectassign(*this,rv); }
1461 #if(CXSC_INDEX_CHECK)
1462  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1463 #else
1464  throw()
1465 #endif
1466  { return _mvvsectassign(*this,l_rvector(rv)); }
1467 
1468  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const interval &c) throw() { return _mvsmultassign(*this,c); }
1469  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const interval &c) throw() { return _mvsplusassign(*this,c); }
1470  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const interval &c) throw() { return _mvsminusassign(*this,c); }
1471  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const interval &c) throw() { return _mvsdivassign(*this,c); }
1473 #if(CXSC_INDEX_CHECK)
1474  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1475 #else
1476  throw()
1477 #endif
1478  { return _mvvplusassign(*this,rv); }
1480 #if(CXSC_INDEX_CHECK)
1481  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1482 #else
1483  throw()
1484 #endif
1485  { return _mvvplusassign(*this,ivector(rv)); }
1487 #if(CXSC_INDEX_CHECK)
1488  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1489 #else
1490  throw()
1491 #endif
1492  { return _mvvminusassign(*this,rv); }
1494 #if(CXSC_INDEX_CHECK)
1495  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1496 #else
1497  throw()
1498 #endif
1499  { return _mvvminusassign(*this,ivector(rv)); }
1501 #if(CXSC_INDEX_CHECK)
1502  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1503 #else
1504  throw()
1505 #endif
1506  { return _mvvconvassign(*this,rv); }
1508 #if(CXSC_INDEX_CHECK)
1509  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1510 #else
1511  throw()
1512 #endif
1513  { return _mvvconvassign(*this,ivector(rv)); }
1515 #if(CXSC_INDEX_CHECK)
1516  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1517 #else
1518  throw()
1519 #endif
1520  { return _mvvsectassign(*this,rv); }
1522 #if(CXSC_INDEX_CHECK)
1523  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1524 #else
1525  throw()
1526 #endif
1527  { return _mvvsectassign(*this,ivector(rv)); }
1528 
1529 
1530  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) throw() { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
1531  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) throw() { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
1532  INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) throw() { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
1533  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
1534  INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) throw() { return _msmultassign(m,c); }
1536 #if(CXSC_INDEX_CHECK)
1537  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1538 #else
1539  throw()
1540 #endif
1541  { return (*this=*this*m); }
1543 #if(CXSC_INDEX_CHECK)
1544  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1545 #else
1546  throw()
1547 #endif
1548  { return (*this=*this*m); }
1549  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_interval &c) throw() { return _mssmultassign(*this,c); }
1550  INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) throw() { return _msdiv<l_imatrix,l_interval,l_imatrix>(m,c); }
1551  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<l_imatrix_slice,l_interval,l_imatrix>(ms,c); }
1552  INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) throw() { return _msdivassign(m,c); }
1553  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_interval &c) throw() { return _mssdivassign(*this,c); }
1554 
1555  INLINE l_imatrix operator *(const real &c, const l_imatrix &m) throw() { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
1556  INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) throw() { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
1557  INLINE l_imatrix operator *(const l_imatrix &m,const real &c) throw() { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
1558  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) throw() { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
1559  INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) throw() { return _msmultassign(m,c); }
1561 #if(CXSC_INDEX_CHECK)
1562  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1563 #else
1564  throw()
1565 #endif
1566  { return (*this=*this*m); }
1568 #if(CXSC_INDEX_CHECK)
1569  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1570 #else
1571  throw()
1572 #endif
1573  { return (*this=*this*m); }
1574  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); }
1575  INLINE l_imatrix operator /(const l_imatrix &m,const real &c) throw() { return _msdiv<l_imatrix,real,l_imatrix>(m,c); }
1576  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) throw() { return _mssdiv<l_imatrix_slice,real,l_imatrix>(ms,c); }
1577  INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) throw() { return _msdivassign(m,c); }
1578  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); }
1579 
1580  INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) throw() { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
1581  INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) throw() { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
1582  INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) throw() { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
1583  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
1584  INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) throw() { return _msmultassign(m,c); }
1586 #if(CXSC_INDEX_CHECK)
1587  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1588 #else
1589  throw()
1590 #endif
1591  { return (*this=*this*m); }
1593 #if(CXSC_INDEX_CHECK)
1594  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1595 #else
1596  throw()
1597 #endif
1598  { return (*this=*this*m); }
1599  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_real &c) throw() { return _mssmultassign(*this,c); }
1600  INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) throw() { return _msdiv<l_imatrix,l_real,l_imatrix>(m,c); }
1601  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) throw() { return _mssdiv<l_imatrix_slice,l_real,l_imatrix>(ms,c); }
1602  INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) throw() { return _msdivassign(m,c); }
1603  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_real &c) throw() { return _mssdivassign(*this,c); }
1604 
1605  INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) throw() { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
1606  INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) throw() { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
1607  INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) throw() { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
1608  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) throw() { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
1609  INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) throw() { return _msmultassign(m,c); }
1611 #if(CXSC_INDEX_CHECK)
1612  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1613 #else
1614  throw()
1615 #endif
1616  { return (*this=*this*m); }
1618 #if(CXSC_INDEX_CHECK)
1619  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1620 #else
1621  throw()
1622 #endif
1623  { return (*this=*this*m); }
1624  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const interval &c) throw() { return _mssmultassign(*this,c); }
1625  INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) throw() { return _msdiv<l_imatrix,interval,l_imatrix>(m,c); }
1626  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) throw() { return _mssdiv<l_imatrix_slice,interval,l_imatrix>(ms,c); }
1627  INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) throw() { return _msdivassign(m,c); }
1628  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const interval &c) throw() { return _mssdivassign(*this,c); }
1629 
1630 // INLINE l_interval::l_interval(const rmatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); }
1631 // INLINE l_interval l_interval::_interval(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
1632 
1633  INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) throw() { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
1634  INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) throw() { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
1635  INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) throw() { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
1636  INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
1637  INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) throw() { return _msdiv<rmatrix,l_interval,l_imatrix>(m,c); }
1638  INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<rmatrix_slice,l_interval,l_imatrix>(ms,c); }
1639 
1640  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) throw() { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
1641  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) throw() { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
1642  INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) throw() { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
1643  INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
1644  INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) throw() { return _msdiv<l_rmatrix,l_interval,l_imatrix>(m,c); }
1645  INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<l_rmatrix_slice,l_interval,l_imatrix>(ms,c); }
1646 
1647  INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) throw() { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
1648  INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) throw() { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
1649  INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) throw() { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
1650  INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
1651  INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) throw() { return _msdiv<imatrix,l_interval,l_imatrix>(m,c); }
1652  INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<imatrix_slice,l_interval,l_imatrix>(ms,c); }
1653 
1655 #if(CXSC_INDEX_CHECK)
1656  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1657 #else
1658  throw()
1659 #endif
1660  { _vmconstr<l_ivector,l_imatrix,l_interval>(*this,sl); }
1662 #if(CXSC_INDEX_CHECK)
1663  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1664 #else
1665  throw()
1666 #endif
1667  { _vmsconstr<l_ivector,l_imatrix_slice,l_interval>(*this,sl); }
1669 #if(CXSC_INDEX_CHECK)
1670  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1671 #else
1672  throw()
1673 #endif
1674  { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,m); }
1676 #if(CXSC_INDEX_CHECK)
1677  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1678 #else
1679  throw()
1680 #endif
1681  { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,l_imatrix(m)); }
1683 #if(CXSC_INDEX_CHECK)
1684  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1685 #else
1686  throw()
1687 #endif
1688  { return _vsvassign(*this,l_ivector(l_imatrix(m))); }
1690 #if(CXSC_INDEX_CHECK)
1691  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1692 #else
1693  throw()
1694 #endif
1695  { return _mvvassign(*this,l_ivector(m)); }
1697 #if(CXSC_INDEX_CHECK)
1698  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1699 #else
1700  throw()
1701 #endif
1702  { return _mvvassign(*this,l_ivector(l_imatrix(m))); }
1703  INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
1704 #if(CXSC_INDEX_CHECK)
1705  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1706 #else
1707  throw()
1708 #endif
1709  { return _mvlimult<l_imatrix,l_ivector,l_ivector>(m,v); }
1710  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
1711 #if(CXSC_INDEX_CHECK)
1712  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1713 #else
1714  throw()
1715 #endif
1716  { return _msvlimult<l_imatrix_slice,l_ivector,l_ivector>(ms,v); }
1717  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
1718 #if(CXSC_INDEX_CHECK)
1719  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1720 #else
1721  throw()
1722 #endif
1723  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(v,m); }
1724  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
1725 #if(CXSC_INDEX_CHECK)
1726  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1727 #else
1728  throw()
1729 #endif
1730  { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(v,ms); }
1732 #if(CXSC_INDEX_CHECK)
1733  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1734 #else
1735  throw()
1736 #endif
1737  { return _vmlimultassign<l_ivector,l_imatrix,l_interval>(v,m); }
1739 #if(CXSC_INDEX_CHECK)
1740  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1741 #else
1742  throw()
1743 #endif
1744  { return _vmslimultassign<l_ivector,l_imatrix_slice,l_interval>(v,ms); }
1746 #if(CXSC_INDEX_CHECK)
1747  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1748 #else
1749  throw()
1750 #endif
1751  { return _vsmlimultassign<l_ivector_slice,l_imatrix,l_interval>(*this,m); }
1752  INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
1753 #if(CXSC_INDEX_CHECK)
1754  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1755 #else
1756  throw()
1757 #endif
1758  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
1760 #if(CXSC_INDEX_CHECK)
1761  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1762 #else
1763  throw()
1764 #endif
1765  { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(l_ivector(v),m); }
1766 
1768 #if(CXSC_INDEX_CHECK)
1769  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1770 #else
1771  throw()
1772 #endif
1773  { return _mvvassign(*this,rvector(m)); }
1775 #if(CXSC_INDEX_CHECK)
1776  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1777 #else
1778  throw()
1779 #endif
1780  { return _mvvassign(*this,rvector(rmatrix(m))); }
1781  INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
1782 #if(CXSC_INDEX_CHECK)
1783  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1784 #else
1785  throw()
1786 #endif
1787  { return _vmlimult<rvector,l_imatrix,l_ivector>(v,m); }
1788  INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
1789 #if(CXSC_INDEX_CHECK)
1790  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1791 #else
1792  throw()
1793 #endif
1794  { return _vmslimult<rvector,l_imatrix_slice,l_ivector>(v,ms); }
1795  INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
1796 #if(CXSC_INDEX_CHECK)
1797  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1798 #else
1799  throw()
1800 #endif
1801  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
1802  INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
1803 #if(CXSC_INDEX_CHECK)
1804  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1805 #else
1806  throw()
1807 #endif
1808  { return _mvlimult<l_imatrix,rvector,l_ivector>(m,v); }
1809  INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
1810 #if(CXSC_INDEX_CHECK)
1811  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1812 #else
1813  throw()
1814 #endif
1815  { return _msvlimult<l_imatrix_slice,rvector,l_ivector>(ms,v); }
1816 
1818 #if(CXSC_INDEX_CHECK)
1819  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1820 #else
1821  throw()
1822 #endif
1823  { return _mvvassign(*this,l_rvector(m)); }
1825 #if(CXSC_INDEX_CHECK)
1826  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1827 #else
1828  throw()
1829 #endif
1830  { return _mvvassign(*this,l_rvector(l_rmatrix(m))); }
1831  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
1832 #if(CXSC_INDEX_CHECK)
1833  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1834 #else
1835  throw()
1836 #endif
1837  { return _vmlimult<l_rvector,l_imatrix,l_ivector>(v,m); }
1838  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
1839 #if(CXSC_INDEX_CHECK)
1840  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1841 #else
1842  throw()
1843 #endif
1844  { return _vmslimult<l_rvector,l_imatrix_slice,l_ivector>(v,ms); }
1845  INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
1846 #if(CXSC_INDEX_CHECK)
1847  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1848 #else
1849  throw()
1850 #endif
1851  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
1852  INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
1853 #if(CXSC_INDEX_CHECK)
1854  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1855 #else
1856  throw()
1857 #endif
1858  { return _mvlimult<l_imatrix,l_rvector,l_ivector>(m,v); }
1859  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
1860 #if(CXSC_INDEX_CHECK)
1861  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1862 #else
1863  throw()
1864 #endif
1865  { return _msvlimult<l_imatrix_slice,l_rvector,l_ivector>(ms,v); }
1866 
1868 #if(CXSC_INDEX_CHECK)
1869  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1870 #else
1871  throw()
1872 #endif
1873  { return _mvvassign(*this,ivector(m)); }
1875 #if(CXSC_INDEX_CHECK)
1876  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1877 #else
1878  throw()
1879 #endif
1880  { return _mvvassign(*this,ivector(imatrix(m))); }
1881  INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
1882 #if(CXSC_INDEX_CHECK)
1883  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1884 #else
1885  throw()
1886 #endif
1887  { return _vmlimult<ivector,l_imatrix,l_ivector>(v,m); }
1888  INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
1889 #if(CXSC_INDEX_CHECK)
1890  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1891 #else
1892  throw()
1893 #endif
1894  { return _vmslimult<ivector,l_imatrix_slice,l_ivector>(v,ms); }
1895  INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
1896 #if(CXSC_INDEX_CHECK)
1897  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1898 #else
1899  throw()
1900 #endif
1901  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
1902  INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
1903 #if(CXSC_INDEX_CHECK)
1904  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1905 #else
1906  throw()
1907 #endif
1908  { return _mvlimult<l_imatrix,ivector,l_ivector>(m,v); }
1909  INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
1910 #if(CXSC_INDEX_CHECK)
1911  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1912 #else
1913  throw()
1914 #endif
1915  { return _msvlimult<l_imatrix_slice,ivector,l_ivector>(ms,v); }
1916 
1917  INLINE const l_imatrix &operator +(const l_imatrix &m) throw() { return m; }
1918  INLINE l_imatrix operator +(const l_imatrix_slice &m) throw() { return l_imatrix(m); }
1919  INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
1920 #if(CXSC_INDEX_CHECK)
1921  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1922 #else
1923  throw()
1924 #endif
1925  { return _mmplus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1926  INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
1927 #if(CXSC_INDEX_CHECK)
1928  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1929 #else
1930  throw()
1931 #endif
1932  { return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1933  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
1934 #if(CXSC_INDEX_CHECK)
1935  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1936 #else
1937  throw()
1938 #endif
1939  { return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1940  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
1941 #if(CXSC_INDEX_CHECK)
1942  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1943 #else
1944  throw()
1945 #endif
1946  { return _msmsplus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
1947  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
1948 #if(CXSC_INDEX_CHECK)
1949  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1950 #else
1951  throw()
1952 #endif
1953  { return _mmplusassign(m1,m2); }
1955 #if(CXSC_INDEX_CHECK)
1956  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1957 #else
1958  throw()
1959 #endif
1960  { return _mmsplusassign(m1,ms); }
1962 #if(CXSC_INDEX_CHECK)
1963  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1964 #else
1965  throw()
1966 #endif
1967  { return _msmplusassign(*this,m1); }
1969 #if(CXSC_INDEX_CHECK)
1970  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1971 #else
1972  throw()
1973 #endif
1974  { return _msmsplusassign(*this,ms2); }
1975  INLINE l_imatrix operator -(const l_imatrix &m) throw() { return _mminus(m); }
1976  INLINE l_imatrix operator -(const l_imatrix_slice &m) throw() { return _msminus<l_imatrix_slice,l_imatrix>(m); }
1977  INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
1978 #if(CXSC_INDEX_CHECK)
1979  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1980 #else
1981  throw()
1982 #endif
1983  { return _mmminus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1984  INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
1985 #if(CXSC_INDEX_CHECK)
1986  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1987 #else
1988  throw()
1989 #endif
1990  { return _mmsminus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1991  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
1992 #if(CXSC_INDEX_CHECK)
1993  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1994 #else
1995  throw()
1996 #endif
1997  { return _msmminus<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
1998  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
1999 #if(CXSC_INDEX_CHECK)
2000  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2001 #else
2002  throw()
2003 #endif
2004  { return _msmsminus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2005  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
2006 #if(CXSC_INDEX_CHECK)
2007  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2008 #else
2009  throw()
2010 #endif
2011  { return _mmminusassign(m1,m2); }
2012  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
2013 #if(CXSC_INDEX_CHECK)
2014  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2015 #else
2016  throw()
2017 #endif
2018  { return _mmsminusassign(m1,ms); }
2020 #if(CXSC_INDEX_CHECK)
2021  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2022 #else
2023  throw()
2024 #endif
2025  { return _msmminusassign(*this,m1); }
2027 #if(CXSC_INDEX_CHECK)
2028  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2029 #else
2030  throw()
2031 #endif
2032  { return _msmsminusassign(*this,ms2); }
2033  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
2034 #if(CXSC_INDEX_CHECK)
2035  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2036 #else
2037  throw()
2038 #endif
2039  { return _mmlimult<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2040  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
2041 #if(CXSC_INDEX_CHECK)
2042  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2043 #else
2044  throw()
2045 #endif
2046  { return _mmslimult<l_imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2047  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
2048 #if(CXSC_INDEX_CHECK)
2049  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2050 #else
2051  throw()
2052 #endif
2053  { return _msmlimult<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2054  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
2055 #if(CXSC_INDEX_CHECK)
2056  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2057 #else
2058  throw()
2059 #endif
2060  { return _msmslimult<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2061  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
2062 #if(CXSC_INDEX_CHECK)
2063  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2064 #else
2065  throw()
2066 #endif
2067  { return _mmlimultassign<l_imatrix,l_imatrix,l_interval>(m1,m2); }
2069 #if(CXSC_INDEX_CHECK)
2070  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2071 #else
2072  throw()
2073 #endif
2074  { return _mmslimultassign<l_imatrix,l_imatrix_slice,l_interval>(m1,ms); }
2075  INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
2076 #if(CXSC_INDEX_CHECK)
2077  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2078 #else
2079  throw()
2080 #endif
2081  { return _mmconv<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2082  INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
2083 #if(CXSC_INDEX_CHECK)
2084  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2085 #else
2086  throw()
2087 #endif
2088  { return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2089  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
2090 #if(CXSC_INDEX_CHECK)
2091  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2092 #else
2093  throw()
2094 #endif
2095  { return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2096  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
2097 #if(CXSC_INDEX_CHECK)
2098  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2099 #else
2100  throw()
2101 #endif
2102  { return _msmsconv<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2103  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
2104 #if(CXSC_INDEX_CHECK)
2105  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2106 #else
2107  throw()
2108 #endif
2109  { return _mmconvassign(m1,m2); }
2110  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
2111 #if(CXSC_INDEX_CHECK)
2112  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2113 #else
2114  throw()
2115 #endif
2116  { return _mmsconvassign(m1,ms); }
2118 #if(CXSC_INDEX_CHECK)
2119  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2120 #else
2121  throw()
2122 #endif
2123  { return _msmconvassign(*this,m1); }
2125 #if(CXSC_INDEX_CHECK)
2126  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2127 #else
2128  throw()
2129 #endif
2130  { return _msmsconvassign(*this,ms2); }
2131  INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
2132 #if(CXSC_INDEX_CHECK)
2133  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2134 #else
2135  throw()
2136 #endif
2137  { return _mmsect<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2138  INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
2139 #if(CXSC_INDEX_CHECK)
2140  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2141 #else
2142  throw()
2143 #endif
2144  { return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2145  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
2146 #if(CXSC_INDEX_CHECK)
2147  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2148 #else
2149  throw()
2150 #endif
2151  { return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2152  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
2153 #if(CXSC_INDEX_CHECK)
2154  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2155 #else
2156  throw()
2157 #endif
2158  { return _msmssect<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2159  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
2160 #if(CXSC_INDEX_CHECK)
2161  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2162 #else
2163  throw()
2164 #endif
2165  { return _mmsectassign(m1,m2); }
2166  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
2167 #if(CXSC_INDEX_CHECK)
2168  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2169 #else
2170  throw()
2171 #endif
2172  { return _mmssectassign(m1,ms); }
2174 #if(CXSC_INDEX_CHECK)
2175  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2176 #else
2177  throw()
2178 #endif
2179  { return _msmsectassign(*this,m1); }
2181 #if(CXSC_INDEX_CHECK)
2182  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2183 #else
2184  throw()
2185 #endif
2186  { return _msmssectassign(*this,ms2); }
2187 
2188  INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
2189 #if(CXSC_INDEX_CHECK)
2190  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2191 #else
2192  throw()
2193 #endif
2194  { return _mmplus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2195  INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
2196 #if(CXSC_INDEX_CHECK)
2197  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2198 #else
2199  throw()
2200 #endif
2201  { return _mmplus<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2202  INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
2203 #if(CXSC_INDEX_CHECK)
2204  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2205 #else
2206  throw()
2207 #endif
2208  { return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2209  INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
2210 #if(CXSC_INDEX_CHECK)
2211  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2212 #else
2213  throw()
2214 #endif
2215  { return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2216  INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
2217 #if(CXSC_INDEX_CHECK)
2218  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2219 #else
2220  throw()
2221 #endif
2222  { return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2223  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
2224 #if(CXSC_INDEX_CHECK)
2225  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2226 #else
2227  throw()
2228 #endif
2229  { return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2230  INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
2231 #if(CXSC_INDEX_CHECK)
2232  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2233 #else
2234  throw()
2235 #endif
2236  { return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2237  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
2238 #if(CXSC_INDEX_CHECK)
2239  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2240 #else
2241  throw()
2242 #endif
2243  { return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2244  INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
2245 #if(CXSC_INDEX_CHECK)
2246  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2247 #else
2248  throw()
2249 #endif
2250  { return _mmplusassign(m1,m2); }
2252 #if(CXSC_INDEX_CHECK)
2253  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2254 #else
2255  throw()
2256 #endif
2257  { return _mmsplusassign(m1,ms); }
2259 #if(CXSC_INDEX_CHECK)
2260  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2261 #else
2262  throw()
2263 #endif
2264  { return _msmplusassign(*this,m1); }
2266 #if(CXSC_INDEX_CHECK)
2267  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2268 #else
2269  throw()
2270 #endif
2271  { return _msmsplusassign(*this,ms2); }
2272  INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
2273 #if(CXSC_INDEX_CHECK)
2274  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2275 #else
2276  throw()
2277 #endif
2278  { return _mmminus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2279  INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
2280 #if(CXSC_INDEX_CHECK)
2281  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2282 #else
2283  throw()
2284 #endif
2285  { return _mmminus<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2286  INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
2287 #if(CXSC_INDEX_CHECK)
2288  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2289 #else
2290  throw()
2291 #endif
2292  { return _mmsminus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2293  INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
2294 #if(CXSC_INDEX_CHECK)
2295  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2296 #else
2297  throw()
2298 #endif
2299  { return _mmsminus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2300  INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
2301 #if(CXSC_INDEX_CHECK)
2302  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2303 #else
2304  throw()
2305 #endif
2306  { return _msmminus<rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2307  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
2308 #if(CXSC_INDEX_CHECK)
2309  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2310 #else
2311  throw()
2312 #endif
2313  { return _msmminus<l_imatrix_slice,rmatrix,l_imatrix>(ms,m); }
2314  INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
2315 #if(CXSC_INDEX_CHECK)
2316  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2317 #else
2318  throw()
2319 #endif
2320  { return _msmsminus<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2321  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
2322 #if(CXSC_INDEX_CHECK)
2323  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2324 #else
2325  throw()
2326 #endif
2327  { return _msmsminus<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2328  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
2329 #if(CXSC_INDEX_CHECK)
2330  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2331 #else
2332  throw()
2333 #endif
2334  { return _mmminusassign(m1,m2); }
2335  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
2336 #if(CXSC_INDEX_CHECK)
2337  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2338 #else
2339  throw()
2340 #endif
2341  { return _mmsminusassign(m1,ms); }
2343 #if(CXSC_INDEX_CHECK)
2344  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2345 #else
2346  throw()
2347 #endif
2348  { return _msmminusassign(*this,m1); }
2350 #if(CXSC_INDEX_CHECK)
2351  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2352 #else
2353  throw()
2354 #endif
2355  { return _msmsminusassign(*this,ms2); }
2356  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
2357 #if(CXSC_INDEX_CHECK)
2358  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2359 #else
2360  throw()
2361 #endif
2362  { return _mmlimult<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2363  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
2364 #if(CXSC_INDEX_CHECK)
2365  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2366 #else
2367  throw()
2368 #endif
2369  { return _mmlimult<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2370  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
2371 #if(CXSC_INDEX_CHECK)
2372  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2373 #else
2374  throw()
2375 #endif
2376  { return _mmslimult<rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2377  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
2378 #if(CXSC_INDEX_CHECK)
2379  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2380 #else
2381  throw()
2382 #endif
2383  { return _mmslimult<l_imatrix,rmatrix_slice,l_imatrix>(m1,ms); }
2384  INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
2385 #if(CXSC_INDEX_CHECK)
2386  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2387 #else
2388  throw()
2389 #endif
2390  { return _msmlimult<rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2391  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
2392 #if(CXSC_INDEX_CHECK)
2393  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2394 #else
2395  throw()
2396 #endif
2397  { return _msmlimult<l_imatrix_slice,rmatrix,l_imatrix>(ms,m1); }
2398  INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
2399 #if(CXSC_INDEX_CHECK)
2400  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2401 #else
2402  throw()
2403 #endif
2404  { return _msmslimult<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2405  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
2406 #if(CXSC_INDEX_CHECK)
2407  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2408 #else
2409  throw()
2410 #endif
2411  { return _msmslimult<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2412  INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
2413 #if(CXSC_INDEX_CHECK)
2414  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2415 #else
2416  throw()
2417 #endif
2418  { return _mmlimultassign<l_imatrix,rmatrix,l_interval>(m1,m2); }
2420 #if(CXSC_INDEX_CHECK)
2421  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2422 #else
2423  throw()
2424 #endif
2425  { return _mmslimultassign<l_imatrix,rmatrix_slice,l_interval>(m1,ms); }
2426  INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
2427 #if(CXSC_INDEX_CHECK)
2428  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2429 #else
2430  throw()
2431 #endif
2432  { return _mmconv<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2433  INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
2434 #if(CXSC_INDEX_CHECK)
2435  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2436 #else
2437  throw()
2438 #endif
2439  { return _mmconv<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2440  INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
2441 #if(CXSC_INDEX_CHECK)
2442  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2443 #else
2444  throw()
2445 #endif
2446  { return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2447  INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
2448 #if(CXSC_INDEX_CHECK)
2449  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2450 #else
2451  throw()
2452 #endif
2453  { return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2454  INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
2455 #if(CXSC_INDEX_CHECK)
2456  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2457 #else
2458  throw()
2459 #endif
2460  { return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2461  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
2462 #if(CXSC_INDEX_CHECK)
2463  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2464 #else
2465  throw()
2466 #endif
2467  { return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2468  INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
2469 #if(CXSC_INDEX_CHECK)
2470  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2471 #else
2472  throw()
2473 #endif
2474  { return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2475  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
2476 #if(CXSC_INDEX_CHECK)
2477  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2478 #else
2479  throw()
2480 #endif
2481  { return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2482  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
2483 #if(CXSC_INDEX_CHECK)
2484  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2485 #else
2486  throw()
2487 #endif
2488  { return _mmconvassign(m1,m2); }
2489  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
2490 #if(CXSC_INDEX_CHECK)
2491  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2492 #else
2493  throw()
2494 #endif
2495  { return _mmsconvassign(m1,ms); }
2497 #if(CXSC_INDEX_CHECK)
2498  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2499 #else
2500  throw()
2501 #endif
2502  { return _msmconvassign(*this,m1); }
2504 #if(CXSC_INDEX_CHECK)
2505  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2506 #else
2507  throw()
2508 #endif
2509  { return _msmsconvassign(*this,ms2); }
2510  INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
2511 #if(CXSC_INDEX_CHECK)
2512  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2513 #else
2514  throw()
2515 #endif
2516  { return _mmsect<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2517  INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
2518 #if(CXSC_INDEX_CHECK)
2519  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2520 #else
2521  throw()
2522 #endif
2523  { return _mmsect<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2524  INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
2525 #if(CXSC_INDEX_CHECK)
2526  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2527 #else
2528  throw()
2529 #endif
2530  { return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2531  INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
2532 #if(CXSC_INDEX_CHECK)
2533  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2534 #else
2535  throw()
2536 #endif
2537  { return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2538  INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
2539 #if(CXSC_INDEX_CHECK)
2540  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2541 #else
2542  throw()
2543 #endif
2544  { return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2545  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
2546 #if(CXSC_INDEX_CHECK)
2547  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2548 #else
2549  throw()
2550 #endif
2551  { return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2552  INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
2553 #if(CXSC_INDEX_CHECK)
2554  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2555 #else
2556  throw()
2557 #endif
2558  { return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2559  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
2560 #if(CXSC_INDEX_CHECK)
2561  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2562 #else
2563  throw()
2564 #endif
2565  { return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2566  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
2567 #if(CXSC_INDEX_CHECK)
2568  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2569 #else
2570  throw()
2571 #endif
2572  { return _mmsectassign(m1,m2); }
2573  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
2574 #if(CXSC_INDEX_CHECK)
2575  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2576 #else
2577  throw()
2578 #endif
2579  { return _mmssectassign(m1,ms); }
2581 #if(CXSC_INDEX_CHECK)
2582  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2583 #else
2584  throw()
2585 #endif
2586  { return _msmsectassign(*this,m1); }
2588 #if(CXSC_INDEX_CHECK)
2589  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2590 #else
2591  throw()
2592 #endif
2593  { return _msmssectassign(*this,ms2); }
2594 
2595  INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
2596 #if(CXSC_INDEX_CHECK)
2597  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2598 #else
2599  throw()
2600 #endif
2601  { return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2602  INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
2603 #if(CXSC_INDEX_CHECK)
2604  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2605 #else
2606  throw()
2607 #endif
2608  { return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2609  INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
2610 #if(CXSC_INDEX_CHECK)
2611  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2612 #else
2613  throw()
2614 #endif
2615  { return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2616  INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
2617 #if(CXSC_INDEX_CHECK)
2618  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2619 #else
2620  throw()
2621 #endif
2622  { return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2623  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
2624 #if(CXSC_INDEX_CHECK)
2625  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2626 #else
2627  throw()
2628 #endif
2629  { return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2630  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
2631 #if(CXSC_INDEX_CHECK)
2632  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2633 #else
2634  throw()
2635 #endif
2636  { return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2637  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
2638 #if(CXSC_INDEX_CHECK)
2639  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2640 #else
2641  throw()
2642 #endif
2643  { return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2644  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
2645 #if(CXSC_INDEX_CHECK)
2646  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2647 #else
2648  throw()
2649 #endif
2650  { return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2651  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
2652 #if(CXSC_INDEX_CHECK)
2653  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2654 #else
2655  throw()
2656 #endif
2657  { return _mmplusassign(m1,m2); }
2659 #if(CXSC_INDEX_CHECK)
2660  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2661 #else
2662  throw()
2663 #endif
2664  { return _mmsplusassign(m1,ms); }
2666 #if(CXSC_INDEX_CHECK)
2667  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2668 #else
2669  throw()
2670 #endif
2671  { return _msmplusassign(*this,m1); }
2673 #if(CXSC_INDEX_CHECK)
2674  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2675 #else
2676  throw()
2677 #endif
2678  { return _msmsplusassign(*this,ms2); }
2679  INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
2680 #if(CXSC_INDEX_CHECK)
2681  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2682 #else
2683  throw()
2684 #endif
2685  { return _mmminus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2686  INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
2687 #if(CXSC_INDEX_CHECK)
2688  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2689 #else
2690  throw()
2691 #endif
2692  { return _mmminus<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2693  INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
2694 #if(CXSC_INDEX_CHECK)
2695  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2696 #else
2697  throw()
2698 #endif
2699  { return _mmsminus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2700  INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
2701 #if(CXSC_INDEX_CHECK)
2702  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2703 #else
2704  throw()
2705 #endif
2706  { return _mmsminus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2707  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
2708 #if(CXSC_INDEX_CHECK)
2709  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2710 #else
2711  throw()
2712 #endif
2713  { return _msmminus<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2714  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
2715 #if(CXSC_INDEX_CHECK)
2716  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2717 #else
2718  throw()
2719 #endif
2720  { return _msmminus<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
2721  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
2722 #if(CXSC_INDEX_CHECK)
2723  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2724 #else
2725  throw()
2726 #endif
2727  { return _msmsminus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2728  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
2729 #if(CXSC_INDEX_CHECK)
2730  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2731 #else
2732  throw()
2733 #endif
2734  { return _msmsminus<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2735  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
2736 #if(CXSC_INDEX_CHECK)
2737  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2738 #else
2739  throw()
2740 #endif
2741  { return _mmminusassign(m1,m2); }
2742  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
2743 #if(CXSC_INDEX_CHECK)
2744  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2745 #else
2746  throw()
2747 #endif
2748  { return _mmsminusassign(m1,ms); }
2750 #if(CXSC_INDEX_CHECK)
2751  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2752 #else
2753  throw()
2754 #endif
2755  { return _msmminusassign(*this,m1); }
2757 #if(CXSC_INDEX_CHECK)
2758  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2759 #else
2760  throw()
2761 #endif
2762  { return _msmsminusassign(*this,ms2); }
2763  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
2764 #if(CXSC_INDEX_CHECK)
2765  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2766 #else
2767  throw()
2768 #endif
2769  { return _mmlimult<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2770  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
2771 #if(CXSC_INDEX_CHECK)
2772  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2773 #else
2774  throw()
2775 #endif
2776  { return _mmlimult<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2777  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
2778 #if(CXSC_INDEX_CHECK)
2779  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2780 #else
2781  throw()
2782 #endif
2783  { return _mmslimult<l_rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2784  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
2785 #if(CXSC_INDEX_CHECK)
2786  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2787 #else
2788  throw()
2789 #endif
2790  { return _mmslimult<l_imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
2791  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
2792 #if(CXSC_INDEX_CHECK)
2793  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2794 #else
2795  throw()
2796 #endif
2797  { return _msmlimult<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2798  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
2799 #if(CXSC_INDEX_CHECK)
2800  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2801 #else
2802  throw()
2803 #endif
2804  { return _msmlimult<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
2805  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
2806 #if(CXSC_INDEX_CHECK)
2807  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2808 #else
2809  throw()
2810 #endif
2811  { return _msmslimult<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2812  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
2813 #if(CXSC_INDEX_CHECK)
2814  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2815 #else
2816  throw()
2817 #endif
2818  { return _msmslimult<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2819  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
2820 #if(CXSC_INDEX_CHECK)
2821  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2822 #else
2823  throw()
2824 #endif
2825  { return _mmlimultassign<l_imatrix,l_rmatrix,l_interval>(m1,m2); }
2827 #if(CXSC_INDEX_CHECK)
2828  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2829 #else
2830  throw()
2831 #endif
2832  { return _mmslimultassign<l_imatrix,l_rmatrix_slice,l_interval>(m1,ms); }
2833  INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
2834 #if(CXSC_INDEX_CHECK)
2835  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2836 #else
2837  throw()
2838 #endif
2839  { return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2840  INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
2841 #if(CXSC_INDEX_CHECK)
2842  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2843 #else
2844  throw()
2845 #endif
2846  { return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2847  INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
2848 #if(CXSC_INDEX_CHECK)
2849  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2850 #else
2851  throw()
2852 #endif
2853  { return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2854  INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
2855 #if(CXSC_INDEX_CHECK)
2856  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2857 #else
2858  throw()
2859 #endif
2860  { return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2861  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
2862 #if(CXSC_INDEX_CHECK)
2863  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2864 #else
2865  throw()
2866 #endif
2867  { return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2868  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
2869 #if(CXSC_INDEX_CHECK)
2870  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2871 #else
2872  throw()
2873 #endif
2874  { return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2875  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
2876 #if(CXSC_INDEX_CHECK)
2877  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2878 #else
2879  throw()
2880 #endif
2881  { return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2882  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
2883 #if(CXSC_INDEX_CHECK)
2884  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2885 #else
2886  throw()
2887 #endif
2888  { return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2889  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
2890 #if(CXSC_INDEX_CHECK)
2891  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2892 #else
2893  throw()
2894 #endif
2895  { return _mmconvassign(m1,m2); }
2896  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
2897 #if(CXSC_INDEX_CHECK)
2898  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2899 #else
2900  throw()
2901 #endif
2902  { return _mmsconvassign(m1,ms); }
2904 #if(CXSC_INDEX_CHECK)
2905  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2906 #else
2907  throw()
2908 #endif
2909  { return _msmconvassign(*this,m1); }
2911 #if(CXSC_INDEX_CHECK)
2912  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2913 #else
2914  throw()
2915 #endif
2916  { return _msmsconvassign(*this,ms2); }
2917  INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
2918 #if(CXSC_INDEX_CHECK)
2919  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2920 #else
2921  throw()
2922 #endif
2923  { return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2924  INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
2925 #if(CXSC_INDEX_CHECK)
2926  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2927 #else
2928  throw()
2929 #endif
2930  { return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2931  INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
2932 #if(CXSC_INDEX_CHECK)
2933  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2934 #else
2935  throw()
2936 #endif
2937  { return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2938  INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
2939 #if(CXSC_INDEX_CHECK)
2940  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2941 #else
2942  throw()
2943 #endif
2944  { return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2945  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
2946 #if(CXSC_INDEX_CHECK)
2947  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2948 #else
2949  throw()
2950 #endif
2951  { return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2952  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
2953 #if(CXSC_INDEX_CHECK)
2954  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2955 #else
2956  throw()
2957 #endif
2958  { return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2959  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
2960 #if(CXSC_INDEX_CHECK)
2961  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2962 #else
2963  throw()
2964 #endif
2965  { return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2966  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
2967 #if(CXSC_INDEX_CHECK)
2968  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2969 #else
2970  throw()
2971 #endif
2972  { return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2973  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
2974 #if(CXSC_INDEX_CHECK)
2975  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2976 #else
2977  throw()
2978 #endif
2979  { return _mmsectassign(m1,m2); }
2980  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
2981 #if(CXSC_INDEX_CHECK)
2982  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2983 #else
2984  throw()
2985 #endif
2986  { return _mmssectassign(m1,ms); }
2988 #if(CXSC_INDEX_CHECK)
2989  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2990 #else
2991  throw()
2992 #endif
2993  { return _msmsectassign(*this,m1); }
2995 #if(CXSC_INDEX_CHECK)
2996  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2997 #else
2998  throw()
2999 #endif
3000  { return _msmssectassign(*this,ms2); }
3001 
3002  INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
3003 #if(CXSC_INDEX_CHECK)
3004  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3005 #else
3006  throw()
3007 #endif
3008  { return _mmplus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3009  INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
3010 #if(CXSC_INDEX_CHECK)
3011  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3012 #else
3013  throw()
3014 #endif
3015  { return _mmplus<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3016  INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
3017 #if(CXSC_INDEX_CHECK)
3018  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3019 #else
3020  throw()
3021 #endif
3022  { return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3023  INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
3024 #if(CXSC_INDEX_CHECK)
3025  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3026 #else
3027  throw()
3028 #endif
3029  { return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3030  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
3031 #if(CXSC_INDEX_CHECK)
3032  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3033 #else
3034  throw()
3035 #endif
3036  { return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3037  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
3038 #if(CXSC_INDEX_CHECK)
3039  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3040 #else
3041  throw()
3042 #endif
3043  { return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3044  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
3045 #if(CXSC_INDEX_CHECK)
3046  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3047 #else
3048  throw()
3049 #endif
3050  { return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3051  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
3052 #if(CXSC_INDEX_CHECK)
3053  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3054 #else
3055  throw()
3056 #endif
3057  { return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3058  INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
3059 #if(CXSC_INDEX_CHECK)
3060  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3061 #else
3062  throw()
3063 #endif
3064  { return _mmplusassign(m1,m2); }
3066 #if(CXSC_INDEX_CHECK)
3067  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3068 #else
3069  throw()
3070 #endif
3071  { return _mmsplusassign(m1,ms); }
3073 #if(CXSC_INDEX_CHECK)
3074  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3075 #else
3076  throw()
3077 #endif
3078  { return _msmplusassign(*this,m1); }
3080 #if(CXSC_INDEX_CHECK)
3081  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3082 #else
3083  throw()
3084 #endif
3085  { return _msmsplusassign(*this,ms2); }
3086  INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
3087 #if(CXSC_INDEX_CHECK)
3088  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3089 #else
3090  throw()
3091 #endif
3092  { return _mmminus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3093  INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
3094 #if(CXSC_INDEX_CHECK)
3095  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3096 #else
3097  throw()
3098 #endif
3099  { return _mmminus<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3100  INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
3101 #if(CXSC_INDEX_CHECK)
3102  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3103 #else
3104  throw()
3105 #endif
3106  { return _mmsminus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3107  INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
3108 #if(CXSC_INDEX_CHECK)
3109  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3110 #else
3111  throw()
3112 #endif
3113  { return _mmsminus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3114  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
3115 #if(CXSC_INDEX_CHECK)
3116  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3117 #else
3118  throw()
3119 #endif
3120  { return _msmminus<imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
3121  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
3122 #if(CXSC_INDEX_CHECK)
3123  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3124 #else
3125  throw()
3126 #endif
3127  { return _msmminus<l_imatrix_slice,imatrix,l_imatrix>(ms,m); }
3128  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
3129 #if(CXSC_INDEX_CHECK)
3130  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3131 #else
3132  throw()
3133 #endif
3134  { return _msmsminus<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3135  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
3136 #if(CXSC_INDEX_CHECK)
3137  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3138 #else
3139  throw()
3140 #endif
3141  { return _msmsminus<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3142  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
3143 #if(CXSC_INDEX_CHECK)
3144  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3145 #else
3146  throw()
3147 #endif
3148  { return _mmminusassign(m1,m2); }
3149  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
3150 #if(CXSC_INDEX_CHECK)
3151  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3152 #else
3153  throw()
3154 #endif
3155  { return _mmsminusassign(m1,ms); }
3157 #if(CXSC_INDEX_CHECK)
3158  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3159 #else
3160  throw()
3161 #endif
3162  { return _msmminusassign(*this,m1); }
3164 #if(CXSC_INDEX_CHECK)
3165  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3166 #else
3167  throw()
3168 #endif
3169  { return _msmsminusassign(*this,ms2); }
3170  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
3171 #if(CXSC_INDEX_CHECK)
3172  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3173 #else
3174  throw()
3175 #endif
3176  { return _mmlimult<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3177  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
3178 #if(CXSC_INDEX_CHECK)
3179  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3180 #else
3181  throw()
3182 #endif
3183  { return _mmlimult<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3184  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
3185 #if(CXSC_INDEX_CHECK)
3186  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3187 #else
3188  throw()
3189 #endif
3190  { return _mmslimult<imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
3191  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
3192 #if(CXSC_INDEX_CHECK)
3193  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3194 #else
3195  throw()
3196 #endif
3197  { return _mmslimult<l_imatrix,imatrix_slice,l_imatrix>(m1,ms); }
3198  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
3199 #if(CXSC_INDEX_CHECK)
3200  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3201 #else
3202  throw()
3203 #endif
3204  { return _msmlimult<imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
3205  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
3206 #if(CXSC_INDEX_CHECK)
3207  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3208 #else
3209  throw()
3210 #endif
3211  { return _msmlimult<l_imatrix_slice,imatrix,l_imatrix>(ms,m1); }
3212  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
3213 #if(CXSC_INDEX_CHECK)
3214  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3215 #else
3216  throw()
3217 #endif
3218  { return _msmslimult<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3219  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
3220 #if(CXSC_INDEX_CHECK)
3221  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3222 #else
3223  throw()
3224 #endif
3225  { return _msmslimult<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3226  INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
3227 #if(CXSC_INDEX_CHECK)
3228  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3229 #else
3230  throw()
3231 #endif
3232  { return _mmlimultassign<l_imatrix,imatrix,l_interval>(m1,m2); }
3234 #if(CXSC_INDEX_CHECK)
3235  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3236 #else
3237  throw()
3238 #endif
3239  { return _mmslimultassign<l_imatrix,imatrix_slice,l_interval>(m1,ms); }
3240  INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
3241 #if(CXSC_INDEX_CHECK)
3242  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3243 #else
3244  throw()
3245 #endif
3246  { return _mmconv<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3247  INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
3248 #if(CXSC_INDEX_CHECK)
3249  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3250 #else
3251  throw()
3252 #endif
3253  { return _mmconv<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3254  INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
3255 #if(CXSC_INDEX_CHECK)
3256  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3257 #else
3258  throw()
3259 #endif
3260  { return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3261  INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
3262 #if(CXSC_INDEX_CHECK)
3263  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3264 #else
3265  throw()
3266 #endif
3267  { return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3268  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
3269 #if(CXSC_INDEX_CHECK)
3270  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3271 #else
3272  throw()
3273 #endif
3274  { return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3275  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
3276 #if(CXSC_INDEX_CHECK)
3277  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3278 #else
3279  throw()
3280 #endif
3281  { return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3282  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
3283 #if(CXSC_INDEX_CHECK)
3284  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3285 #else
3286  throw()
3287 #endif
3288  { return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3289  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
3290 #if(CXSC_INDEX_CHECK)
3291  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3292 #else
3293  throw()
3294 #endif
3295  { return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3296  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
3297 #if(CXSC_INDEX_CHECK)
3298  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3299 #else
3300  throw()
3301 #endif
3302  { return _mmconvassign(m1,m2); }
3303  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
3304 #if(CXSC_INDEX_CHECK)
3305  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3306 #else
3307  throw()
3308 #endif
3309  { return _mmsconvassign(m1,ms); }
3311 #if(CXSC_INDEX_CHECK)
3312  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3313 #else
3314  throw()
3315 #endif
3316  { return _msmconvassign(*this,m1); }
3318 #if(CXSC_INDEX_CHECK)
3319  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3320 #else
3321  throw()
3322 #endif
3323  { return _msmsconvassign(*this,ms2); }
3324  INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
3325 #if(CXSC_INDEX_CHECK)
3326  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3327 #else
3328  throw()
3329 #endif
3330  { return _mmsect<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3331  INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
3332 #if(CXSC_INDEX_CHECK)
3333  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3334 #else
3335  throw()
3336 #endif
3337  { return _mmsect<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3338  INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
3339 #if(CXSC_INDEX_CHECK)
3340  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3341 #else
3342  throw()
3343 #endif
3344  { return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3345  INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
3346 #if(CXSC_INDEX_CHECK)
3347  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3348 #else
3349  throw()
3350 #endif
3351  { return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3352  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
3353 #if(CXSC_INDEX_CHECK)
3354  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3355 #else
3356  throw()
3357 #endif
3358  { return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3359  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
3360 #if(CXSC_INDEX_CHECK)
3361  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3362 #else
3363  throw()
3364 #endif
3365  { return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3366  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
3367 #if(CXSC_INDEX_CHECK)
3368  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3369 #else
3370  throw()
3371 #endif
3372  { return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3373  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
3374 #if(CXSC_INDEX_CHECK)
3375  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3376 #else
3377  throw()
3378 #endif
3379  { return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3380  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
3381 #if(CXSC_INDEX_CHECK)
3382  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3383 #else
3384  throw()
3385 #endif
3386  { return _mmsectassign(m1,m2); }
3387  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
3388 #if(CXSC_INDEX_CHECK)
3389  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3390 #else
3391  throw()
3392 #endif
3393  { return _mmssectassign(m1,ms); }
3395 #if(CXSC_INDEX_CHECK)
3396  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3397 #else
3398  throw()
3399 #endif
3400  { return _msmsectassign(*this,m1); }
3402 #if(CXSC_INDEX_CHECK)
3403  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3404 #else
3405  throw()
3406 #endif
3407  { return _msmssectassign(*this,ms2); }
3408 
3409  INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
3410 #if(CXSC_INDEX_CHECK)
3411  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3412 #else
3413  throw()
3414 #endif
3415  { return _mmplus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3416  INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
3417 #if(CXSC_INDEX_CHECK)
3418  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3419 #else
3420  throw()
3421 #endif
3422  { return _mmplus<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3423  INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
3424 #if(CXSC_INDEX_CHECK)
3425  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3426 #else
3427  throw()
3428 #endif
3429  { return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3430  INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
3431 #if(CXSC_INDEX_CHECK)
3432  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3433 #else
3434  throw()
3435 #endif
3436  { return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3437  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
3438 #if(CXSC_INDEX_CHECK)
3439  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3440 #else
3441  throw()
3442 #endif
3443  { return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3444  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
3445 #if(CXSC_INDEX_CHECK)
3446  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3447 #else
3448  throw()
3449 #endif
3450  { return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3451  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
3452 #if(CXSC_INDEX_CHECK)
3453  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3454 #else
3455  throw()
3456 #endif
3457  { return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3458  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
3459 #if(CXSC_INDEX_CHECK)
3460  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3461 #else
3462  throw()
3463 #endif
3464  { return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3465  INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
3466 #if(CXSC_INDEX_CHECK)
3467  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3468 #else
3469  throw()
3470 #endif
3471  { return _mmminus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3472  INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
3473 #if(CXSC_INDEX_CHECK)
3474  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3475 #else
3476  throw()
3477 #endif
3478  { return _mmminus<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3479  INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
3480 #if(CXSC_INDEX_CHECK)
3481  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3482 #else
3483  throw()
3484 #endif
3485  { return _mmsminus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3486  INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
3487 #if(CXSC_INDEX_CHECK)
3488  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3489 #else
3490  throw()
3491 #endif
3492  { return _mmsminus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3493  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
3494 #if(CXSC_INDEX_CHECK)
3495  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3496 #else
3497  throw()
3498 #endif
3499  { return _msmminus<l_rmatrix_slice,imatrix,l_imatrix>(ms,m); }
3500  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
3501 #if(CXSC_INDEX_CHECK)
3502  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3503 #else
3504  throw()
3505 #endif
3506  { return _msmminus<imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
3507  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
3508 #if(CXSC_INDEX_CHECK)
3509  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3510 #else
3511  throw()
3512 #endif
3513  { return _msmsminus<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3514  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
3515 #if(CXSC_INDEX_CHECK)
3516  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3517 #else
3518  throw()
3519 #endif
3520  { return _msmsminus<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3521  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
3522 #if(CXSC_INDEX_CHECK)
3523  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3524 #else
3525  throw()
3526 #endif
3527  { return _mmlimult<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3528  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
3529 #if(CXSC_INDEX_CHECK)
3530  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3531 #else
3532  throw()
3533 #endif
3534  { return _mmlimult<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3535  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
3536 #if(CXSC_INDEX_CHECK)
3537  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3538 #else
3539  throw()
3540 #endif
3541  { return _mmslimult<l_rmatrix,imatrix_slice,l_imatrix>(m1,ms); }
3542  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
3543 #if(CXSC_INDEX_CHECK)
3544  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3545 #else
3546  throw()
3547 #endif
3548  { return _mmslimult<imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
3549  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
3550 #if(CXSC_INDEX_CHECK)
3551  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3552 #else
3553  throw()
3554 #endif
3555  { return _msmlimult<l_rmatrix_slice,imatrix,l_imatrix>(ms,m1); }
3556  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
3557 #if(CXSC_INDEX_CHECK)
3558  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3559 #else
3560  throw()
3561 #endif
3562  { return _msmlimult<imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
3563  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
3564 #if(CXSC_INDEX_CHECK)
3565  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3566 #else
3567  throw()
3568 #endif
3569  { return _msmslimult<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3570  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
3571 #if(CXSC_INDEX_CHECK)
3572  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3573 #else
3574  throw()
3575 #endif
3576  { return _msmslimult<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3577  INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
3578 #if(CXSC_INDEX_CHECK)
3579  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3580 #else
3581  throw()
3582 #endif
3583  { return _mmconv<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3584  INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
3585 #if(CXSC_INDEX_CHECK)
3586  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3587 #else
3588  throw()
3589 #endif
3590  { return _mmconv<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3591  INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
3592 #if(CXSC_INDEX_CHECK)
3593  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3594 #else
3595  throw()
3596 #endif
3597  { return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3598  INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
3599 #if(CXSC_INDEX_CHECK)
3600  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3601 #else
3602  throw()
3603 #endif
3604  { return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3605  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
3606 #if(CXSC_INDEX_CHECK)
3607  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3608 #else
3609  throw()
3610 #endif
3611  { return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3612  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
3613 #if(CXSC_INDEX_CHECK)
3614  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3615 #else
3616  throw()
3617 #endif
3618  { return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3619  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
3620 #if(CXSC_INDEX_CHECK)
3621  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3622 #else
3623  throw()
3624 #endif
3625  { return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3626  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
3627 #if(CXSC_INDEX_CHECK)
3628  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3629 #else
3630  throw()
3631 #endif
3632  { return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3633  INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
3634 #if(CXSC_INDEX_CHECK)
3635  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3636 #else
3637  throw()
3638 #endif
3639  { return _mmsect<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3640  INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
3641 #if(CXSC_INDEX_CHECK)
3642  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3643 #else
3644  throw()
3645 #endif
3646  { return _mmsect<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3647  INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
3648 #if(CXSC_INDEX_CHECK)
3649  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3650 #else
3651  throw()
3652 #endif
3653  { return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3654  INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
3655 #if(CXSC_INDEX_CHECK)
3656  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3657 #else
3658  throw()
3659 #endif
3660  { return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3661  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
3662 #if(CXSC_INDEX_CHECK)
3663  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3664 #else
3665  throw()
3666 #endif
3667  { return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3668  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
3669 #if(CXSC_INDEX_CHECK)
3670  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3671 #else
3672  throw()
3673 #endif
3674  { return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3675  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
3676 #if(CXSC_INDEX_CHECK)
3677  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3678 #else
3679  throw()
3680 #endif
3681  { return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3682  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
3683 #if(CXSC_INDEX_CHECK)
3684  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3685 #else
3686  throw()
3687 #endif
3688  { return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3689 
3690 //------------- real x l_real ------------------------
3691  INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
3692 #if(CXSC_INDEX_CHECK)
3693  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3694 #else
3695  throw()
3696 #endif
3697  { return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3698  INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
3699 #if(CXSC_INDEX_CHECK)
3700  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3701 #else
3702  throw()
3703 #endif
3704  { return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv2,rv1); }
3705  INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
3706 #if(CXSC_INDEX_CHECK)
3707  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3708 #else
3709  throw()
3710 #endif
3711  { return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3712  INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
3713 #if(CXSC_INDEX_CHECK)
3714  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3715 #else
3716  throw()
3717 #endif
3718  { return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3719  INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
3720 #if(CXSC_INDEX_CHECK)
3721  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3722 #else
3723  throw()
3724 #endif
3725  { return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3726  INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
3727 #if(CXSC_INDEX_CHECK)
3728  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3729 #else
3730  throw()
3731 #endif
3732  { return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3733  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
3734 #if(CXSC_INDEX_CHECK)
3735  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3736 #else
3737  throw()
3738 #endif
3739  { return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl2,sl1); }
3740  INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
3741 #if(CXSC_INDEX_CHECK)
3742  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3743 #else
3744  throw()
3745 #endif
3746  { return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3747 
3748 //------------- l_real x l_real ------------------------
3749  INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
3750 #if(CXSC_INDEX_CHECK)
3751  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3752 #else
3753  throw()
3754 #endif
3755  { return _mmconv<l_rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3756  INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
3757 #if(CXSC_INDEX_CHECK)
3758  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3759 #else
3760  throw()
3761 #endif
3762  { return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3763  INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
3764 #if(CXSC_INDEX_CHECK)
3765  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3766 #else
3767  throw()
3768 #endif
3769  { return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3770  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
3771 #if(CXSC_INDEX_CHECK)
3772  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3773 #else
3774  throw()
3775 #endif
3776  { return _msmsconv<l_rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3777 
3778  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmeq(m1,m2); }
3779  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmneq(m1,m2); }
3780  INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmless(m1,m2); }
3781  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmleq(m1,m2); }
3782  INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmless(m2,m1); }
3783  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmleq(m2,m1); }
3784  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmseq(m1,ms); }
3785  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsneq(m1,ms); }
3786  INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsless(m1,ms); }
3787  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsleq(m1,ms); }
3788  INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _msmless(ms,m1); }
3789  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _msmleq(ms,m1); }
3790  INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmseq(m1,m2); }
3791  INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsneq(m1,m2); }
3792  INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsless(m1,m2); }
3793  INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsleq(m1,m2); }
3794  INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsless(m2,m1); }
3795  INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsleq(m2,m1); }
3796  INLINE bool operator !(const l_imatrix &ms) throw() { return _mnot(ms); }
3797  INLINE bool operator !(const l_imatrix_slice &ms) throw() { return _msnot(ms); }
3798  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) throw() { return _mout(s,r); }
3799  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) throw() { return _msout(s,r); }
3800  INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) throw() { return _min(s,r); }
3801  INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) throw() { return _msin(s,r); }
3802 
3803 } // namespace cxsc
3804 
3805 #endif
3806 
cxsc::l_imatrix_slice::operator=
l_imatrix_slice & operator=(const l_imatrix &m)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:522
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:999
cxsc::l_imatrix_subv::operator[]
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_imatrix.inl:185
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::l_imatrix_subv::operator&=
l_imatrix_subv & operator&=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:972
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1441
cxsc::mid
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_imatrix_subv::operator|=
l_imatrix_subv & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:923
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::l_rmatrix_subv
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:46
cxsc::l_imatrix_slice::operator*=
l_imatrix_slice & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:1549
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:55
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:54
cxsc::l_imatrix_subv::operator+=
l_imatrix_subv & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
Definition: l_imatrix.inl:675
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:470
cxsc::diam
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:415
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:57
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:47
cxsc::_imatrix
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cimatrix.inl:1137
cxsc::l_ivector_slice::operator=
l_ivector_slice & operator=(const l_ivector_slice &sl)
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:962
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1063
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::l_imatrix_subv::operator-=
l_imatrix_subv & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
Definition: l_imatrix.inl:676
cxsc::l_imatrix_subv::operator()
l_imatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: l_imatrix.hpp:436
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:659
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::l_imatrix_slice
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1279
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:71
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:54
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::l_imatrix_subv::operator=
l_imatrix_subv & operator=(const l_imatrix_subv &rv)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:428
cxsc::l_imatrix::operator()
l_imatrix & operator()()
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1252
cxsc::l_imatrix::operator=
l_imatrix & operator=(const l_interval &r)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:496
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:744
cxsc::l_ivector::l_ivector
l_ivector()
Constructor of class l_ivector.
Definition: l_ivector.inl:31
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
cxsc::l_imatrix::l_imatrix
l_imatrix()
Constructor of class l_imatrix.
Definition: l_imatrix.inl:31
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::Lb
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
cxsc::l_imatrix_slice::operator()
l_imatrix_slice & operator()()
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1760
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
cxsc::l_imatrix_slice::operator&=
l_imatrix_slice & operator&=(const l_imatrix &m1)
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:2173
cxsc::Ub
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::l_imatrix_subv::operator*=
l_imatrix_subv & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:674
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
cxsc::l_imatrix_slice::operator|=
l_imatrix_slice & operator|=(const l_imatrix &m1)
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:2117
cxsc::l_imatrix_slice::operator-=
l_imatrix_slice & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
cxsc::l_ivector_slice
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:870
cxsc::l_imatrix_slice::operator/=
l_imatrix_slice & operator/=(const l_interval &c)
Implementation of division and allocation operation.
Definition: l_imatrix.inl:1553
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
cxsc::l_ivector::operator=
l_ivector & operator=(const l_ivector &rv)
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
cxsc::l_imatrix_slice::operator[]
l_imatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:348
cxsc::l_ivector_slice::operator*=
l_ivector_slice & operator*=(const l_interval &r)
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
cxsc::l_imatrix_subv
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:46
cxsc::l_imatrix::operator[]
l_imatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:296
cxsc::l_imatrix_subv::operator/=
l_imatrix_subv & operator/=(const l_interval &c)
Implementation of division and allocation operation.
Definition: l_imatrix.inl:677
cxsc::l_imatrix_slice::operator+=
l_imatrix_slice & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
cxsc::l_interval::l_interval
l_interval()
Constructor of class l_interval.
Definition: l_interval.inl:45
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:113