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() noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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 :lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
90 #else
91  noexcept: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 :lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
103 #else
104  noexcept: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) noexcept: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 
123 #else
124 noexcept
125 #endif
126 { return _vsvassign(*this,l_ivector(m)); }
127 
128 
129 INLINE l_imatrix::l_imatrix(const l_ivector &v) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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) noexcept: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 
188 #else
189  noexcept
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) noexcept: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) noexcept: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) noexcept: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) noexcept: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 
255 #else
256  noexcept
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 
266 #else
267  noexcept
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 
277 #else
278  noexcept
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 
288 #else
289  noexcept
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 
299 #else
300  noexcept
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 
312 #else
313  noexcept
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 
325 #else
326  noexcept
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 
338 #else
339  noexcept
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 
351 #else
352  noexcept
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 
364 #else
365  noexcept
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 
377 #else
378  noexcept
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 
390 #else
391  noexcept
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 
403 #else
404  noexcept
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 
416 #else
417  noexcept
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) noexcept { return _mvmvassign(*this,rv); }
429  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_interval &r) noexcept { return _mvsassign(*this,r); }
431 #if(CXSC_INDEX_CHECK)
432 
433 #else
434  noexcept
435 #endif
436  { return _mvvassign(*this,v); }
438 #if(CXSC_INDEX_CHECK)
439 
440 #else
441  noexcept
442 #endif
443  { return _mvvassign(*this,l_ivector(v)); }
444 
445  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rmatrix_subv &rv) noexcept { return _mvvassign(*this,rvector(rv)); }
446  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const real &r) noexcept { return _mvsassign(*this,r); }
448 #if(CXSC_INDEX_CHECK)
449 
450 #else
451  noexcept
452 #endif
453  { return _mvvassign(*this,v); }
455 #if(CXSC_INDEX_CHECK)
456 
457 #else
458  noexcept
459 #endif
460  { return _mvvassign(*this,l_ivector(v)); }
461 
462  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rmatrix_subv &rv) noexcept { return _mvvassign(*this,l_rvector(rv)); }
463  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_real &r) noexcept { return _mvsassign(*this,r); }
465 #if(CXSC_INDEX_CHECK)
466 
467 #else
468  noexcept
469 #endif
470  { return _mvvassign(*this,v); }
472 #if(CXSC_INDEX_CHECK)
473 
474 #else
475  noexcept
476 #endif
477  { return _mvvassign(*this,l_ivector(v)); }
478 
479  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const imatrix_subv &rv) noexcept { return _mvvassign(*this,ivector(rv)); }
480  INLINE l_imatrix_subv &l_imatrix_subv::operator =(const interval &r) noexcept { return _mvsassign(*this,r); }
482 #if(CXSC_INDEX_CHECK)
483 
484 #else
485  noexcept
486 #endif
487  { return _mvvassign(*this,v); }
489 #if(CXSC_INDEX_CHECK)
490 
491 #else
492  noexcept
493 #endif
494  { return _mvvassign(*this,l_ivector(v)); }
495 
496  INLINE l_imatrix &l_imatrix::operator =(const l_interval &r) noexcept { return _msassign(*this,r); }
497  INLINE l_imatrix &l_imatrix::operator =(const l_imatrix &m) noexcept { return _mmassign<l_imatrix,l_imatrix,l_interval>(*this,m, l_interval()); }
498  INLINE l_imatrix &l_imatrix::operator =(const l_imatrix_slice &ms) noexcept { return _mmsassign<l_imatrix,l_imatrix_slice,l_interval>(*this,ms); }
499  INLINE l_imatrix &l_imatrix::operator =(const l_ivector &v) noexcept { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,v); }
500  INLINE l_imatrix &l_imatrix::operator =(const l_ivector_slice &v) noexcept { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,l_ivector(v)); }
501 
502  INLINE l_imatrix &l_imatrix::operator =(const real &r) noexcept { return _msassign(*this,l_interval(r)); }
503  INLINE l_imatrix &l_imatrix::operator =(const rmatrix &m) noexcept { return _mmassign<l_imatrix,rmatrix,l_interval>(*this,m, l_interval()); }
504  INLINE l_imatrix &l_imatrix::operator =(const rmatrix_slice &ms) noexcept { return _mmsassign<l_imatrix,rmatrix_slice,l_interval>(*this,ms); }
505  INLINE l_imatrix &l_imatrix::operator =(const rvector &v) noexcept { return _mvassign<l_imatrix,rvector,l_interval>(*this,v); }
506  INLINE l_imatrix &l_imatrix::operator =(const rvector_slice &v) noexcept { return _mvassign<l_imatrix,rvector,l_interval>(*this,rvector(v)); }
507 
508  INLINE l_imatrix &l_imatrix::operator =(const l_real &r) noexcept { return _msassign(*this,l_interval(r)); }
509  INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix &m) noexcept { return _mmassign<l_imatrix,l_rmatrix,l_interval>(*this,m, l_interval()); }
510  INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix_slice &ms) noexcept { return _mmsassign<l_imatrix,l_rmatrix_slice,l_interval>(*this,ms); }
511  INLINE l_imatrix &l_imatrix::operator =(const l_rvector &v) noexcept { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,v); }
512  INLINE l_imatrix &l_imatrix::operator =(const l_rvector_slice &v) noexcept { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,l_rvector(v)); }
513 
514  INLINE l_imatrix &l_imatrix::operator =(const interval &r) noexcept { return _msassign(*this,l_interval(r)); }
515  INLINE l_imatrix &l_imatrix::operator =(const imatrix &m) noexcept { return _mmassign<l_imatrix,imatrix,l_interval>(*this,m, l_interval()); }
516  INLINE l_imatrix &l_imatrix::operator =(const imatrix_slice &ms) noexcept { return _mmsassign<l_imatrix,imatrix_slice,l_interval>(*this,ms); }
517  INLINE l_imatrix &l_imatrix::operator =(const ivector &v) noexcept { return _mvassign<l_imatrix,ivector,l_interval>(*this,v); }
518  INLINE l_imatrix &l_imatrix::operator =(const ivector_slice &v) noexcept { return _mvassign<l_imatrix,ivector,l_interval>(*this,ivector(v)); }
519 
520  INLINE l_imatrix::operator void*() noexcept { return _mvoid(*this); }
521 
523 #if(CXSC_INDEX_CHECK)
524 
525 #else
526  noexcept
527 #endif
528  { return _msmassign(*this,m); }
530 #if(CXSC_INDEX_CHECK)
531 
532 #else
533  noexcept
534 #endif
535  { return _msmsassign(*this,ms); }
536  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_interval &r) noexcept { return _mssassign(*this,r); }
538 #if(CXSC_INDEX_CHECK)
539 
540 #else
541  noexcept
542 #endif
543  { return _msmassign(*this,l_imatrix(v)); }
545 #if(CXSC_INDEX_CHECK)
546 
547 #else
548  noexcept
549 #endif
550  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
552 #if(CXSC_INDEX_CHECK)
553 
554 #else
555  noexcept
556 #endif
557  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
558 
560 #if(CXSC_INDEX_CHECK)
561 
562 #else
563  noexcept
564 #endif
565  { return _msmassign(*this,m); }
567 #if(CXSC_INDEX_CHECK)
568 
569 #else
570  noexcept
571 #endif
572  { return _msmsassign(*this,ms); }
573  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const real &r) noexcept { return _mssassign(*this,r); }
575 #if(CXSC_INDEX_CHECK)
576 
577 #else
578  noexcept
579 #endif
580  { return _msmassign(*this,l_imatrix(v)); }
582 #if(CXSC_INDEX_CHECK)
583 
584 #else
585  noexcept
586 #endif
587  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
589 #if(CXSC_INDEX_CHECK)
590 
591 #else
592  noexcept
593 #endif
594  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
595 
597 #if(CXSC_INDEX_CHECK)
598 
599 #else
600  noexcept
601 #endif
602  { return _msmassign(*this,m); }
604 #if(CXSC_INDEX_CHECK)
605 
606 #else
607  noexcept
608 #endif
609  { return _msmsassign(*this,ms); }
610  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_real &r) noexcept { return _mssassign(*this,r); }
612 #if(CXSC_INDEX_CHECK)
613 
614 #else
615  noexcept
616 #endif
617  { return _msmassign(*this,l_imatrix(v)); }
619 #if(CXSC_INDEX_CHECK)
620 
621 #else
622  noexcept
623 #endif
624  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
626 #if(CXSC_INDEX_CHECK)
627 
628 #else
629  noexcept
630 #endif
631  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
632 
634 #if(CXSC_INDEX_CHECK)
635 
636 #else
637  noexcept
638 #endif
639  { return _msmassign(*this,m); }
641 #if(CXSC_INDEX_CHECK)
642 
643 #else
644  noexcept
645 #endif
646  { return _msmsassign(*this,ms); }
647  INLINE l_imatrix_slice &l_imatrix_slice::operator =(const interval &r) noexcept { return _mssassign(*this,r); }
649 #if(CXSC_INDEX_CHECK)
650 
651 #else
652  noexcept
653 #endif
654  { return _msmassign(*this,l_imatrix(v)); }
656 #if(CXSC_INDEX_CHECK)
657 
658 #else
659  noexcept
660 #endif
661  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
663 #if(CXSC_INDEX_CHECK)
664 
665 #else
666  noexcept
667 #endif
668  { return _msmassign(*this,l_imatrix(l_ivector(v))); }
669 
670  INLINE l_imatrix_slice::operator void*() noexcept { return _msvoid(*this); }
671  INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) noexcept { 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) noexcept { 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) noexcept { return _mvsmult<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
674  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_interval &c) noexcept { return _mvsmultassign(*this,c); }
675  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_interval &c) noexcept { return _mvsplusassign(*this,c); }
676  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_interval &c) noexcept { return _mvsminusassign(*this,c); }
677  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_interval &c) noexcept { return _mvsdivassign(*this,c); }
678  INLINE l_ivector abs(const l_imatrix_subv &mv) noexcept { return _mvabs<l_imatrix_subv,l_ivector>(mv); }
679  INLINE l_rvector diam(const l_imatrix_subv &mv) noexcept { return _mvdiam<l_imatrix_subv,l_rvector>(mv); }
680  INLINE l_rvector mid(const l_imatrix_subv &mv) noexcept { return _mvmid<l_imatrix_subv,l_rvector>(mv); }
681  INLINE l_rvector Inf(const l_imatrix_subv &mv) noexcept { return _mvinf<l_imatrix_subv,l_rvector>(mv); }
682  INLINE l_rvector Sup(const l_imatrix_subv &mv) noexcept { 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 
687 #else
688  noexcept
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 
694 #else
695  noexcept
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 
701 #else
702  noexcept
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 
708 #else
709  noexcept
710 #endif
711  { return _mvvusetsup(iv,rv); }
712  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) noexcept { return _mvssetsup(iv,r); }
713  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) noexcept { return _mvssetinf(iv,r); }
714  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) noexcept { return _mvsusetsup(iv,r); }
715  INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) noexcept { return _mvsusetinf(iv,r); }
716  INLINE l_ivector &l_ivector::operator =(const l_imatrix_subv &mv) noexcept { 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) noexcept { 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 
722 #else
723  noexcept
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 
729 #else
730  noexcept
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 
736 #else
737  noexcept
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 
743 #else
744  noexcept
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 
750 #else
751  noexcept
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 
758 #else
759  noexcept
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 
765 #else
766  noexcept
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 
772 #else
773  noexcept
774 #endif
775  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv2,rv1); }
777 #if(CXSC_INDEX_CHECK)
778 
779 #else
780  noexcept
781 #endif
782  { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(l_ivector(sl),sv); }
784 #if(CXSC_INDEX_CHECK)
785 
786 #else
787  noexcept
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 
793 #else
794  noexcept
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 
800 #else
801  noexcept
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 
807 #else
808  noexcept
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 
814 #else
815  noexcept
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 
821 #else
822  noexcept
823 #endif
824  { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
826 #if(CXSC_INDEX_CHECK)
827 
828 #else
829  noexcept
830 #endif
831  { return _mvvplusassign(*this,rv); }
833 #if(CXSC_INDEX_CHECK)
834 
835 #else
836  noexcept
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 
842 #else
843  noexcept
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 
849 #else
850  noexcept
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 
856 #else
857  noexcept
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 
863 #else
864  noexcept
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 
870 #else
871  noexcept
872 #endif
873  { return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
875 #if(CXSC_INDEX_CHECK)
876 
877 #else
878  noexcept
879 #endif
880  { return _mvvminusassign(*this,rv); }
882 #if(CXSC_INDEX_CHECK)
883 
884 #else
885  noexcept
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 
891 #else
892  noexcept
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 
898 #else
899  noexcept
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 
905 #else
906  noexcept
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 
912 #else
913  noexcept
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 
919 #else
920  noexcept
921 #endif
922  { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
924 #if(CXSC_INDEX_CHECK)
925 
926 #else
927  noexcept
928 #endif
929  { return _mvvconvassign(*this,rv); }
931 #if(CXSC_INDEX_CHECK)
932 
933 #else
934  noexcept
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 
940 #else
941  noexcept
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 
947 #else
948  noexcept
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 
954 #else
955  noexcept
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 
961 #else
962  noexcept
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 
968 #else
969  noexcept
970 #endif
971  { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
973 #if(CXSC_INDEX_CHECK)
974 
975 #else
976  noexcept
977 #endif
978  { return _mvvsectassign(*this,rv); }
980 #if(CXSC_INDEX_CHECK)
981 
982 #else
983  noexcept
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 
991 #else
992  noexcept
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 
998 #else
999  noexcept
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 
1005 #else
1006  noexcept
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 
1012 #else
1013  noexcept
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 
1019 #else
1020  noexcept
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 
1026 #else
1027  noexcept
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 
1034 #else
1035  noexcept
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 
1041 #else
1042  noexcept
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 
1048 #else
1049  noexcept
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 
1055 #else
1056  noexcept
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 
1062 #else
1063  noexcept
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 
1069 #else
1070  noexcept
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 
1077 #else
1078  noexcept
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 
1084 #else
1085  noexcept
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 
1091 #else
1092  noexcept
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 
1098 #else
1099  noexcept
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 
1105 #else
1106  noexcept
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 
1112 #else
1113  noexcept
1114 #endif
1115  { _vmvaccu(dp,rv1,rv2); }
1116 
1117 
1118 
1119 // matrix x matrix
1125  INLINE l_imatrix _imatrix(const l_imatrix &rm) noexcept { return rm; }
1131  INLINE l_imatrix _imatrix(const l_ivector &v) noexcept { return l_imatrix(v); }
1137  INLINE l_imatrix _imatrix(const l_ivector_slice &v) noexcept { return l_imatrix(v); }
1143  INLINE l_imatrix _imatrix(const l_interval &r) noexcept { return l_imatrix(r); }
1144  INLINE int Lb(const l_imatrix &rm, const int &i)
1145 #if(CXSC_INDEX_CHECK)
1146 
1147 #else
1148  noexcept
1149 #endif
1150  { return _mlb(rm,i); }
1151  INLINE int Ub(const l_imatrix &rm, const int &i)
1152 #if(CXSC_INDEX_CHECK)
1153 
1154 #else
1155  noexcept
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 
1161 #else
1162  noexcept
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 
1168 #else
1169  noexcept
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 
1175 #else
1176  noexcept
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 
1182 #else
1183  noexcept
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) noexcept { _mresize(A);}
1201  INLINE void Resize(l_imatrix &A,const int &m, const int &n)
1202 #if(CXSC_INDEX_CHECK)
1203 
1204 #else
1205  noexcept
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 
1211 #else
1212  noexcept
1213 #endif
1214  { _mresize<l_imatrix,l_interval>(A,m1,m2,n1,n2); }
1215  INLINE l_imatrix abs(const l_imatrix &m) noexcept { return _mabs<l_imatrix,l_imatrix>(m); }
1216  INLINE l_imatrix abs(const l_imatrix_slice &ms) noexcept { return _msabs<l_imatrix_slice,l_imatrix>(ms); }
1217  INLINE l_rmatrix diam(const l_imatrix &m) noexcept { return _mdiam<l_imatrix,l_rmatrix>(m); }
1218  INLINE l_rmatrix diam(const l_imatrix_slice &m) noexcept { return _msdiam<l_imatrix_slice,l_rmatrix>(m); }
1219  INLINE l_rmatrix mid(const l_imatrix &m) noexcept { return _mmid<l_imatrix,l_rmatrix>(m); }
1220  INLINE l_rmatrix mid(const l_imatrix_slice &m) noexcept { return _msmid<l_imatrix_slice,l_rmatrix>(m); }
1221  INLINE l_rmatrix Inf(const l_imatrix &m) noexcept { return _minf<l_imatrix,l_rmatrix>(m); }
1222  INLINE l_rmatrix Sup(const l_imatrix &m) noexcept { return _msup<l_imatrix,l_rmatrix>(m); }
1223  INLINE l_rmatrix Inf(const l_imatrix_slice &m) noexcept { return _msinf<l_imatrix_slice,l_rmatrix>(m); }
1224  INLINE l_rmatrix Sup(const l_imatrix_slice &m) noexcept { 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 
1228 #else
1229  noexcept
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 
1235 #else
1236  noexcept
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 
1242 #else
1243  noexcept
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 
1249 #else
1250  noexcept
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 
1256 #else
1257  noexcept
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 
1263 #else
1264  noexcept
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 
1270 #else
1271  noexcept
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 
1277 #else
1278  noexcept
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 
1284 #else
1285  noexcept
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 
1291 #else
1292  noexcept
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 
1298 #else
1299  noexcept
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 
1305 #else
1306  noexcept
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 
1312 #else
1313  noexcept
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 
1319 #else
1320  noexcept
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 
1326 #else
1327  noexcept
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 
1333 #else
1334  noexcept
1335 #endif
1336  { return _msmsusetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1338 #if(CXSC_INDEX_CHECK)
1339 
1340 #else
1341  noexcept
1342 #endif
1343  { _smconstr(*this,m); }
1344 // INLINE l_interval l_interval::_interval(const l_imatrix &m) { _smconstr(*this,m); return *this; }
1345 
1346  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const real &c) noexcept { return _mvsmultassign(*this,c); }
1347  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const real &c) noexcept { return _mvsplusassign(*this,c); }
1348  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const real &c) noexcept { return _mvsminusassign(*this,c); }
1349  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const real &c) noexcept { return _mvsdivassign(*this,c); }
1351 #if(CXSC_INDEX_CHECK)
1352 
1353 #else
1354  noexcept
1355 #endif
1356  { return _mvvplusassign(*this,rv); }
1358 #if(CXSC_INDEX_CHECK)
1359 
1360 #else
1361  noexcept
1362 #endif
1363  { return _mvvplusassign(*this,rvector(rv)); }
1365 #if(CXSC_INDEX_CHECK)
1366 
1367 #else
1368  noexcept
1369 #endif
1370  { return _mvvminusassign(*this,rv); }
1372 #if(CXSC_INDEX_CHECK)
1373 
1374 #else
1375  noexcept
1376 #endif
1377  { return _mvvminusassign(*this,rvector(rv)); }
1379 #if(CXSC_INDEX_CHECK)
1380 
1381 #else
1382  noexcept
1383 #endif
1384  { return _mvvconvassign(*this,rv); }
1386 #if(CXSC_INDEX_CHECK)
1387 
1388 #else
1389  noexcept
1390 #endif
1391  { return _mvvconvassign(*this,rvector(rv)); }
1393 #if(CXSC_INDEX_CHECK)
1394 
1395 #else
1396  noexcept
1397 #endif
1398  { return _mvvsectassign(*this,rv); }
1400 #if(CXSC_INDEX_CHECK)
1401 
1402 #else
1403  noexcept
1404 #endif
1405  { return _mvvsectassign(*this,rvector(rv)); }
1406 
1407  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_real &c) noexcept { return _mvsmultassign(*this,c); }
1408  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_real &c) noexcept { return _mvsplusassign(*this,c); }
1409  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_real &c) noexcept { return _mvsminusassign(*this,c); }
1410  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_real &c) noexcept { return _mvsdivassign(*this,c); }
1412 #if(CXSC_INDEX_CHECK)
1413 
1414 #else
1415  noexcept
1416 #endif
1417  { return _mvvplusassign(*this,rv); }
1419 #if(CXSC_INDEX_CHECK)
1420 
1421 #else
1422  noexcept
1423 #endif
1424  { return _mvvplusassign(*this,l_rvector(rv)); }
1426 #if(CXSC_INDEX_CHECK)
1427 
1428 #else
1429  noexcept
1430 #endif
1431  { return _mvvminusassign(*this,rv); }
1433 #if(CXSC_INDEX_CHECK)
1434 
1435 #else
1436  noexcept
1437 #endif
1438  { return _mvvminusassign(*this,l_rvector(rv)); }
1440 #if(CXSC_INDEX_CHECK)
1441 
1442 #else
1443  noexcept
1444 #endif
1445  { return _mvvconvassign(*this,rv); }
1447 #if(CXSC_INDEX_CHECK)
1448 
1449 #else
1450  noexcept
1451 #endif
1452  { return _mvvconvassign(*this,l_rvector(rv)); }
1454 #if(CXSC_INDEX_CHECK)
1455 
1456 #else
1457  noexcept
1458 #endif
1459  { return _mvvsectassign(*this,rv); }
1461 #if(CXSC_INDEX_CHECK)
1462 
1463 #else
1464  noexcept
1465 #endif
1466  { return _mvvsectassign(*this,l_rvector(rv)); }
1467 
1468  INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const interval &c) noexcept { return _mvsmultassign(*this,c); }
1469  INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const interval &c) noexcept { return _mvsplusassign(*this,c); }
1470  INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const interval &c) noexcept { return _mvsminusassign(*this,c); }
1471  INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const interval &c) noexcept { return _mvsdivassign(*this,c); }
1473 #if(CXSC_INDEX_CHECK)
1474 
1475 #else
1476  noexcept
1477 #endif
1478  { return _mvvplusassign(*this,rv); }
1480 #if(CXSC_INDEX_CHECK)
1481 
1482 #else
1483  noexcept
1484 #endif
1485  { return _mvvplusassign(*this,ivector(rv)); }
1487 #if(CXSC_INDEX_CHECK)
1488 
1489 #else
1490  noexcept
1491 #endif
1492  { return _mvvminusassign(*this,rv); }
1494 #if(CXSC_INDEX_CHECK)
1495 
1496 #else
1497  noexcept
1498 #endif
1499  { return _mvvminusassign(*this,ivector(rv)); }
1501 #if(CXSC_INDEX_CHECK)
1502 
1503 #else
1504  noexcept
1505 #endif
1506  { return _mvvconvassign(*this,rv); }
1508 #if(CXSC_INDEX_CHECK)
1509 
1510 #else
1511  noexcept
1512 #endif
1513  { return _mvvconvassign(*this,ivector(rv)); }
1515 #if(CXSC_INDEX_CHECK)
1516 
1517 #else
1518  noexcept
1519 #endif
1520  { return _mvvsectassign(*this,rv); }
1522 #if(CXSC_INDEX_CHECK)
1523 
1524 #else
1525  noexcept
1526 #endif
1527  { return _mvvsectassign(*this,ivector(rv)); }
1528 
1529 
1530  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) noexcept { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
1531  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) noexcept { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
1532  INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) noexcept { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
1533  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) noexcept { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
1534  INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) noexcept { return _msmultassign(m,c); }
1536 #if(CXSC_INDEX_CHECK)
1537 
1538 #else
1539  noexcept
1540 #endif
1541  { return (*this=*this*m); }
1543 #if(CXSC_INDEX_CHECK)
1544 
1545 #else
1546  noexcept
1547 #endif
1548  { return (*this=*this*m); }
1549  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_interval &c) noexcept { return _mssmultassign(*this,c); }
1550  INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) noexcept { return _msdiv<l_imatrix,l_interval,l_imatrix>(m,c); }
1551  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) noexcept { return _mssdiv<l_imatrix_slice,l_interval,l_imatrix>(ms,c); }
1552  INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) noexcept { return _msdivassign(m,c); }
1553  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_interval &c) noexcept { return _mssdivassign(*this,c); }
1554 
1555  INLINE l_imatrix operator *(const real &c, const l_imatrix &m) noexcept { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
1556  INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) noexcept { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
1557  INLINE l_imatrix operator *(const l_imatrix &m,const real &c) noexcept { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
1558  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) noexcept { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
1559  INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) noexcept { return _msmultassign(m,c); }
1561 #if(CXSC_INDEX_CHECK)
1562 
1563 #else
1564  noexcept
1565 #endif
1566  { return (*this=*this*m); }
1568 #if(CXSC_INDEX_CHECK)
1569 
1570 #else
1571  noexcept
1572 #endif
1573  { return (*this=*this*m); }
1574  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const real &c) noexcept { return _mssmultassign(*this,c); }
1575  INLINE l_imatrix operator /(const l_imatrix &m,const real &c) noexcept { return _msdiv<l_imatrix,real,l_imatrix>(m,c); }
1576  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) noexcept { return _mssdiv<l_imatrix_slice,real,l_imatrix>(ms,c); }
1577  INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) noexcept { return _msdivassign(m,c); }
1578  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const real &c) noexcept { return _mssdivassign(*this,c); }
1579 
1580  INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) noexcept { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
1581  INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) noexcept { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
1582  INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) noexcept { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
1583  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) noexcept { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
1584  INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) noexcept { return _msmultassign(m,c); }
1586 #if(CXSC_INDEX_CHECK)
1587 
1588 #else
1589  noexcept
1590 #endif
1591  { return (*this=*this*m); }
1593 #if(CXSC_INDEX_CHECK)
1594 
1595 #else
1596  noexcept
1597 #endif
1598  { return (*this=*this*m); }
1599  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_real &c) noexcept { return _mssmultassign(*this,c); }
1600  INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) noexcept { return _msdiv<l_imatrix,l_real,l_imatrix>(m,c); }
1601  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) noexcept { return _mssdiv<l_imatrix_slice,l_real,l_imatrix>(ms,c); }
1602  INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) noexcept { return _msdivassign(m,c); }
1603  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_real &c) noexcept { return _mssdivassign(*this,c); }
1604 
1605  INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) noexcept { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
1606  INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) noexcept { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
1607  INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) noexcept { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
1608  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) noexcept { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
1609  INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) noexcept { return _msmultassign(m,c); }
1611 #if(CXSC_INDEX_CHECK)
1612 
1613 #else
1614  noexcept
1615 #endif
1616  { return (*this=*this*m); }
1618 #if(CXSC_INDEX_CHECK)
1619 
1620 #else
1621  noexcept
1622 #endif
1623  { return (*this=*this*m); }
1624  INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const interval &c) noexcept { return _mssmultassign(*this,c); }
1625  INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) noexcept { return _msdiv<l_imatrix,interval,l_imatrix>(m,c); }
1626  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) noexcept { return _mssdiv<l_imatrix_slice,interval,l_imatrix>(ms,c); }
1627  INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) noexcept { return _msdivassign(m,c); }
1628  INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const interval &c) noexcept { return _mssdivassign(*this,c); }
1629 
1630 // INLINE l_interval::l_interval(const rmatrix &m) { _smconstr(*this,m); }
1631 // INLINE l_interval l_interval::_interval(const l_imatrix &m) { _smconstr(*this,m); return *this; }
1632 
1633  INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) noexcept { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
1634  INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) noexcept { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
1635  INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) noexcept { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
1636  INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) noexcept { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
1637  INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) noexcept { return _msdiv<rmatrix,l_interval,l_imatrix>(m,c); }
1638  INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) noexcept { return _mssdiv<rmatrix_slice,l_interval,l_imatrix>(ms,c); }
1639 
1640  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) noexcept { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
1641  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) noexcept { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
1642  INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) noexcept { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
1643  INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) noexcept { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
1644  INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) noexcept { return _msdiv<l_rmatrix,l_interval,l_imatrix>(m,c); }
1645  INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) noexcept { return _mssdiv<l_rmatrix_slice,l_interval,l_imatrix>(ms,c); }
1646 
1647  INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) noexcept { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
1648  INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) noexcept { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
1649  INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) noexcept { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
1650  INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) noexcept { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
1651  INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) noexcept { return _msdiv<imatrix,l_interval,l_imatrix>(m,c); }
1652  INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) noexcept { return _mssdiv<imatrix_slice,l_interval,l_imatrix>(ms,c); }
1653 
1655 #if(CXSC_INDEX_CHECK)
1656 
1657 #else
1658  noexcept
1659 #endif
1660  { _vmconstr<l_ivector,l_imatrix,l_interval>(*this,sl); }
1662 #if(CXSC_INDEX_CHECK)
1663 
1664 #else
1665  noexcept
1666 #endif
1667  { _vmsconstr<l_ivector,l_imatrix_slice,l_interval>(*this,sl); }
1669 #if(CXSC_INDEX_CHECK)
1670 
1671 #else
1672  noexcept
1673 #endif
1674  { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,m); }
1676 #if(CXSC_INDEX_CHECK)
1677 
1678 #else
1679  noexcept
1680 #endif
1681  { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,l_imatrix(m)); }
1683 #if(CXSC_INDEX_CHECK)
1684 
1685 #else
1686  noexcept
1687 #endif
1688  { return _vsvassign(*this,l_ivector(l_imatrix(m))); }
1690 #if(CXSC_INDEX_CHECK)
1691 
1692 #else
1693  noexcept
1694 #endif
1695  { return _mvvassign(*this,l_ivector(m)); }
1697 #if(CXSC_INDEX_CHECK)
1698 
1699 #else
1700  noexcept
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 
1706 #else
1707  noexcept
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 
1713 #else
1714  noexcept
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 
1720 #else
1721  noexcept
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 
1727 #else
1728  noexcept
1729 #endif
1730  { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(v,ms); }
1732 #if(CXSC_INDEX_CHECK)
1733 
1734 #else
1735  noexcept
1736 #endif
1737  { return _vmlimultassign<l_ivector,l_imatrix,l_interval>(v,m); }
1739 #if(CXSC_INDEX_CHECK)
1740 
1741 #else
1742  noexcept
1743 #endif
1744  { return _vmslimultassign<l_ivector,l_imatrix_slice,l_interval>(v,ms); }
1746 #if(CXSC_INDEX_CHECK)
1747 
1748 #else
1749  noexcept
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 
1755 #else
1756  noexcept
1757 #endif
1758  { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
1760 #if(CXSC_INDEX_CHECK)
1761 
1762 #else
1763  noexcept
1764 #endif
1765  { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(l_ivector(v),m); }
1766 
1768 #if(CXSC_INDEX_CHECK)
1769 
1770 #else
1771  noexcept
1772 #endif
1773  { return _mvvassign(*this,rvector(m)); }
1775 #if(CXSC_INDEX_CHECK)
1776 
1777 #else
1778  noexcept
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 
1784 #else
1785  noexcept
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 
1791 #else
1792  noexcept
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 
1798 #else
1799  noexcept
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 
1805 #else
1806  noexcept
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 
1812 #else
1813  noexcept
1814 #endif
1815  { return _msvlimult<l_imatrix_slice,rvector,l_ivector>(ms,v); }
1816 
1818 #if(CXSC_INDEX_CHECK)
1819 
1820 #else
1821  noexcept
1822 #endif
1823  { return _mvvassign(*this,l_rvector(m)); }
1825 #if(CXSC_INDEX_CHECK)
1826 
1827 #else
1828  noexcept
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 
1834 #else
1835  noexcept
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 
1841 #else
1842  noexcept
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 
1848 #else
1849  noexcept
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 
1855 #else
1856  noexcept
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 
1862 #else
1863  noexcept
1864 #endif
1865  { return _msvlimult<l_imatrix_slice,l_rvector,l_ivector>(ms,v); }
1866 
1868 #if(CXSC_INDEX_CHECK)
1869 
1870 #else
1871  noexcept
1872 #endif
1873  { return _mvvassign(*this,ivector(m)); }
1875 #if(CXSC_INDEX_CHECK)
1876 
1877 #else
1878  noexcept
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 
1884 #else
1885  noexcept
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 
1891 #else
1892  noexcept
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 
1898 #else
1899  noexcept
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 
1905 #else
1906  noexcept
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 
1912 #else
1913  noexcept
1914 #endif
1915  { return _msvlimult<l_imatrix_slice,ivector,l_ivector>(ms,v); }
1916 
1917  INLINE const l_imatrix &operator +(const l_imatrix &m) noexcept { return m; }
1918  INLINE l_imatrix operator +(const l_imatrix_slice &m) noexcept { return l_imatrix(m); }
1919  INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
1920 #if(CXSC_INDEX_CHECK)
1921 
1922 #else
1923  noexcept
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 
1929 #else
1930  noexcept
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 
1936 #else
1937  noexcept
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 
1943 #else
1944  noexcept
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 
1950 #else
1951  noexcept
1952 #endif
1953  { return _mmplusassign(m1,m2); }
1955 #if(CXSC_INDEX_CHECK)
1956 
1957 #else
1958  noexcept
1959 #endif
1960  { return _mmsplusassign(m1,ms); }
1962 #if(CXSC_INDEX_CHECK)
1963 
1964 #else
1965  noexcept
1966 #endif
1967  { return _msmplusassign(*this,m1); }
1969 #if(CXSC_INDEX_CHECK)
1970 
1971 #else
1972  noexcept
1973 #endif
1974  { return _msmsplusassign(*this,ms2); }
1975  INLINE l_imatrix operator -(const l_imatrix &m) noexcept { return _mminus(m); }
1976  INLINE l_imatrix operator -(const l_imatrix_slice &m) noexcept { 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 
1980 #else
1981  noexcept
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 
1987 #else
1988  noexcept
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 
1994 #else
1995  noexcept
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 
2001 #else
2002  noexcept
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 
2008 #else
2009  noexcept
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 
2015 #else
2016  noexcept
2017 #endif
2018  { return _mmsminusassign(m1,ms); }
2020 #if(CXSC_INDEX_CHECK)
2021 
2022 #else
2023  noexcept
2024 #endif
2025  { return _msmminusassign(*this,m1); }
2027 #if(CXSC_INDEX_CHECK)
2028 
2029 #else
2030  noexcept
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 
2036 #else
2037  noexcept
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 
2043 #else
2044  noexcept
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 
2050 #else
2051  noexcept
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 
2057 #else
2058  noexcept
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 
2064 #else
2065  noexcept
2066 #endif
2067  { return _mmlimultassign<l_imatrix,l_imatrix,l_interval>(m1,m2); }
2069 #if(CXSC_INDEX_CHECK)
2070 
2071 #else
2072  noexcept
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 
2078 #else
2079  noexcept
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 
2085 #else
2086  noexcept
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 
2092 #else
2093  noexcept
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 
2099 #else
2100  noexcept
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 
2106 #else
2107  noexcept
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 
2113 #else
2114  noexcept
2115 #endif
2116  { return _mmsconvassign(m1,ms); }
2118 #if(CXSC_INDEX_CHECK)
2119 
2120 #else
2121  noexcept
2122 #endif
2123  { return _msmconvassign(*this,m1); }
2125 #if(CXSC_INDEX_CHECK)
2126 
2127 #else
2128  noexcept
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 
2134 #else
2135  noexcept
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 
2141 #else
2142  noexcept
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 
2148 #else
2149  noexcept
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 
2155 #else
2156  noexcept
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 
2162 #else
2163  noexcept
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 
2169 #else
2170  noexcept
2171 #endif
2172  { return _mmssectassign(m1,ms); }
2174 #if(CXSC_INDEX_CHECK)
2175 
2176 #else
2177  noexcept
2178 #endif
2179  { return _msmsectassign(*this,m1); }
2181 #if(CXSC_INDEX_CHECK)
2182 
2183 #else
2184  noexcept
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 
2191 #else
2192  noexcept
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 
2198 #else
2199  noexcept
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 
2205 #else
2206  noexcept
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 
2212 #else
2213  noexcept
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 
2219 #else
2220  noexcept
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 
2226 #else
2227  noexcept
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 
2233 #else
2234  noexcept
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 
2240 #else
2241  noexcept
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 
2247 #else
2248  noexcept
2249 #endif
2250  { return _mmplusassign(m1,m2); }
2252 #if(CXSC_INDEX_CHECK)
2253 
2254 #else
2255  noexcept
2256 #endif
2257  { return _mmsplusassign(m1,ms); }
2259 #if(CXSC_INDEX_CHECK)
2260 
2261 #else
2262  noexcept
2263 #endif
2264  { return _msmplusassign(*this,m1); }
2266 #if(CXSC_INDEX_CHECK)
2267 
2268 #else
2269  noexcept
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 
2275 #else
2276  noexcept
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 
2282 #else
2283  noexcept
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 
2289 #else
2290  noexcept
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 
2296 #else
2297  noexcept
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 
2303 #else
2304  noexcept
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 
2310 #else
2311  noexcept
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 
2317 #else
2318  noexcept
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 
2324 #else
2325  noexcept
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 
2331 #else
2332  noexcept
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 
2338 #else
2339  noexcept
2340 #endif
2341  { return _mmsminusassign(m1,ms); }
2343 #if(CXSC_INDEX_CHECK)
2344 
2345 #else
2346  noexcept
2347 #endif
2348  { return _msmminusassign(*this,m1); }
2350 #if(CXSC_INDEX_CHECK)
2351 
2352 #else
2353  noexcept
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 
2359 #else
2360  noexcept
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 
2366 #else
2367  noexcept
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 
2373 #else
2374  noexcept
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 
2380 #else
2381  noexcept
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 
2387 #else
2388  noexcept
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 
2394 #else
2395  noexcept
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 
2401 #else
2402  noexcept
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 
2408 #else
2409  noexcept
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 
2415 #else
2416  noexcept
2417 #endif
2418  { return _mmlimultassign<l_imatrix,rmatrix,l_interval>(m1,m2); }
2420 #if(CXSC_INDEX_CHECK)
2421 
2422 #else
2423  noexcept
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 
2429 #else
2430  noexcept
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 
2436 #else
2437  noexcept
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 
2443 #else
2444  noexcept
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 
2450 #else
2451  noexcept
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 
2457 #else
2458  noexcept
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 
2464 #else
2465  noexcept
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 
2471 #else
2472  noexcept
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 
2478 #else
2479  noexcept
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 
2485 #else
2486  noexcept
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 
2492 #else
2493  noexcept
2494 #endif
2495  { return _mmsconvassign(m1,ms); }
2497 #if(CXSC_INDEX_CHECK)
2498 
2499 #else
2500  noexcept
2501 #endif
2502  { return _msmconvassign(*this,m1); }
2504 #if(CXSC_INDEX_CHECK)
2505 
2506 #else
2507  noexcept
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 
2513 #else
2514  noexcept
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 
2520 #else
2521  noexcept
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 
2527 #else
2528  noexcept
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 
2534 #else
2535  noexcept
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 
2541 #else
2542  noexcept
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 
2548 #else
2549  noexcept
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 
2555 #else
2556  noexcept
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 
2562 #else
2563  noexcept
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 
2569 #else
2570  noexcept
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 
2576 #else
2577  noexcept
2578 #endif
2579  { return _mmssectassign(m1,ms); }
2581 #if(CXSC_INDEX_CHECK)
2582 
2583 #else
2584  noexcept
2585 #endif
2586  { return _msmsectassign(*this,m1); }
2588 #if(CXSC_INDEX_CHECK)
2589 
2590 #else
2591  noexcept
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 
2598 #else
2599  noexcept
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 
2605 #else
2606  noexcept
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 
2612 #else
2613  noexcept
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 
2619 #else
2620  noexcept
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 
2626 #else
2627  noexcept
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 
2633 #else
2634  noexcept
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 
2640 #else
2641  noexcept
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 
2647 #else
2648  noexcept
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 
2654 #else
2655  noexcept
2656 #endif
2657  { return _mmplusassign(m1,m2); }
2659 #if(CXSC_INDEX_CHECK)
2660 
2661 #else
2662  noexcept
2663 #endif
2664  { return _mmsplusassign(m1,ms); }
2666 #if(CXSC_INDEX_CHECK)
2667 
2668 #else
2669  noexcept
2670 #endif
2671  { return _msmplusassign(*this,m1); }
2673 #if(CXSC_INDEX_CHECK)
2674 
2675 #else
2676  noexcept
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 
2682 #else
2683  noexcept
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 
2689 #else
2690  noexcept
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 
2696 #else
2697  noexcept
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 
2703 #else
2704  noexcept
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 
2710 #else
2711  noexcept
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 
2717 #else
2718  noexcept
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 
2724 #else
2725  noexcept
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 
2731 #else
2732  noexcept
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 
2738 #else
2739  noexcept
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 
2745 #else
2746  noexcept
2747 #endif
2748  { return _mmsminusassign(m1,ms); }
2750 #if(CXSC_INDEX_CHECK)
2751 
2752 #else
2753  noexcept
2754 #endif
2755  { return _msmminusassign(*this,m1); }
2757 #if(CXSC_INDEX_CHECK)
2758 
2759 #else
2760  noexcept
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 
2766 #else
2767  noexcept
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 
2773 #else
2774  noexcept
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 
2780 #else
2781  noexcept
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 
2787 #else
2788  noexcept
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 
2794 #else
2795  noexcept
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 
2801 #else
2802  noexcept
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 
2808 #else
2809  noexcept
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 
2815 #else
2816  noexcept
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 
2822 #else
2823  noexcept
2824 #endif
2825  { return _mmlimultassign<l_imatrix,l_rmatrix,l_interval>(m1,m2); }
2827 #if(CXSC_INDEX_CHECK)
2828 
2829 #else
2830  noexcept
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 
2836 #else
2837  noexcept
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 
2843 #else
2844  noexcept
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 
2850 #else
2851  noexcept
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 
2857 #else
2858  noexcept
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 
2864 #else
2865  noexcept
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 
2871 #else
2872  noexcept
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 
2878 #else
2879  noexcept
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 
2885 #else
2886  noexcept
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 
2892 #else
2893  noexcept
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 
2899 #else
2900  noexcept
2901 #endif
2902  { return _mmsconvassign(m1,ms); }
2904 #if(CXSC_INDEX_CHECK)
2905 
2906 #else
2907  noexcept
2908 #endif
2909  { return _msmconvassign(*this,m1); }
2911 #if(CXSC_INDEX_CHECK)
2912 
2913 #else
2914  noexcept
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 
2920 #else
2921  noexcept
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 
2927 #else
2928  noexcept
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 
2934 #else
2935  noexcept
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 
2941 #else
2942  noexcept
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 
2948 #else
2949  noexcept
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 
2955 #else
2956  noexcept
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 
2962 #else
2963  noexcept
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 
2969 #else
2970  noexcept
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 
2976 #else
2977  noexcept
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 
2983 #else
2984  noexcept
2985 #endif
2986  { return _mmssectassign(m1,ms); }
2988 #if(CXSC_INDEX_CHECK)
2989 
2990 #else
2991  noexcept
2992 #endif
2993  { return _msmsectassign(*this,m1); }
2995 #if(CXSC_INDEX_CHECK)
2996 
2997 #else
2998  noexcept
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 
3005 #else
3006  noexcept
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 
3012 #else
3013  noexcept
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 
3019 #else
3020  noexcept
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 
3026 #else
3027  noexcept
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 
3033 #else
3034  noexcept
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 
3040 #else
3041  noexcept
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 
3047 #else
3048  noexcept
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 
3054 #else
3055  noexcept
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 
3061 #else
3062  noexcept
3063 #endif
3064  { return _mmplusassign(m1,m2); }
3066 #if(CXSC_INDEX_CHECK)
3067 
3068 #else
3069  noexcept
3070 #endif
3071  { return _mmsplusassign(m1,ms); }
3073 #if(CXSC_INDEX_CHECK)
3074 
3075 #else
3076  noexcept
3077 #endif
3078  { return _msmplusassign(*this,m1); }
3080 #if(CXSC_INDEX_CHECK)
3081 
3082 #else
3083  noexcept
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 
3089 #else
3090  noexcept
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 
3096 #else
3097  noexcept
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 
3103 #else
3104  noexcept
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 
3110 #else
3111  noexcept
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 
3117 #else
3118  noexcept
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 
3124 #else
3125  noexcept
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 
3131 #else
3132  noexcept
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 
3138 #else
3139  noexcept
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 
3145 #else
3146  noexcept
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 
3152 #else
3153  noexcept
3154 #endif
3155  { return _mmsminusassign(m1,ms); }
3157 #if(CXSC_INDEX_CHECK)
3158 
3159 #else
3160  noexcept
3161 #endif
3162  { return _msmminusassign(*this,m1); }
3164 #if(CXSC_INDEX_CHECK)
3165 
3166 #else
3167  noexcept
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 
3173 #else
3174  noexcept
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 
3180 #else
3181  noexcept
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 
3187 #else
3188  noexcept
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 
3194 #else
3195  noexcept
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 
3201 #else
3202  noexcept
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 
3208 #else
3209  noexcept
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 
3215 #else
3216  noexcept
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 
3222 #else
3223  noexcept
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 
3229 #else
3230  noexcept
3231 #endif
3232  { return _mmlimultassign<l_imatrix,imatrix,l_interval>(m1,m2); }
3234 #if(CXSC_INDEX_CHECK)
3235 
3236 #else
3237  noexcept
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 
3243 #else
3244  noexcept
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 
3250 #else
3251  noexcept
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 
3257 #else
3258  noexcept
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 
3264 #else
3265  noexcept
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 
3271 #else
3272  noexcept
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 
3278 #else
3279  noexcept
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 
3285 #else
3286  noexcept
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 
3292 #else
3293  noexcept
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 
3299 #else
3300  noexcept
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 
3306 #else
3307  noexcept
3308 #endif
3309  { return _mmsconvassign(m1,ms); }
3311 #if(CXSC_INDEX_CHECK)
3312 
3313 #else
3314  noexcept
3315 #endif
3316  { return _msmconvassign(*this,m1); }
3318 #if(CXSC_INDEX_CHECK)
3319 
3320 #else
3321  noexcept
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 
3327 #else
3328  noexcept
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 
3334 #else
3335  noexcept
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 
3341 #else
3342  noexcept
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 
3348 #else
3349  noexcept
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 
3355 #else
3356  noexcept
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 
3362 #else
3363  noexcept
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 
3369 #else
3370  noexcept
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 
3376 #else
3377  noexcept
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 
3383 #else
3384  noexcept
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 
3390 #else
3391  noexcept
3392 #endif
3393  { return _mmssectassign(m1,ms); }
3395 #if(CXSC_INDEX_CHECK)
3396 
3397 #else
3398  noexcept
3399 #endif
3400  { return _msmsectassign(*this,m1); }
3402 #if(CXSC_INDEX_CHECK)
3403 
3404 #else
3405  noexcept
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 
3412 #else
3413  noexcept
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 
3419 #else
3420  noexcept
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 
3426 #else
3427  noexcept
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 
3433 #else
3434  noexcept
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 
3440 #else
3441  noexcept
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 
3447 #else
3448  noexcept
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 
3454 #else
3455  noexcept
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 
3461 #else
3462  noexcept
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 
3468 #else
3469  noexcept
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 
3475 #else
3476  noexcept
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 
3482 #else
3483  noexcept
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 
3489 #else
3490  noexcept
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 
3496 #else
3497  noexcept
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 
3503 #else
3504  noexcept
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 
3510 #else
3511  noexcept
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 
3517 #else
3518  noexcept
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 
3524 #else
3525  noexcept
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 
3531 #else
3532  noexcept
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 
3538 #else
3539  noexcept
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 
3545 #else
3546  noexcept
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 
3552 #else
3553  noexcept
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 
3559 #else
3560  noexcept
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 
3566 #else
3567  noexcept
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 
3573 #else
3574  noexcept
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 
3580 #else
3581  noexcept
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 
3587 #else
3588  noexcept
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 
3594 #else
3595  noexcept
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 
3601 #else
3602  noexcept
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 
3608 #else
3609  noexcept
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 
3615 #else
3616  noexcept
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 
3622 #else
3623  noexcept
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 
3629 #else
3630  noexcept
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 
3636 #else
3637  noexcept
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 
3643 #else
3644  noexcept
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 
3650 #else
3651  noexcept
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 
3657 #else
3658  noexcept
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 
3664 #else
3665  noexcept
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 
3671 #else
3672  noexcept
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 
3678 #else
3679  noexcept
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 
3685 #else
3686  noexcept
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 
3694 #else
3695  noexcept
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 
3701 #else
3702  noexcept
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 
3708 #else
3709  noexcept
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 
3715 #else
3716  noexcept
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 
3722 #else
3723  noexcept
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 
3729 #else
3730  noexcept
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 
3736 #else
3737  noexcept
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 
3743 #else
3744  noexcept
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 
3752 #else
3753  noexcept
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 
3759 #else
3760  noexcept
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 
3766 #else
3767  noexcept
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 
3773 #else
3774  noexcept
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) noexcept { return _mmeq(m1,m2); }
3779  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) noexcept { return _mmneq(m1,m2); }
3780  INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) noexcept { return _mmless(m1,m2); }
3781  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) noexcept { return _mmleq(m1,m2); }
3782  INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) noexcept { return _mmless(m2,m1); }
3783  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) noexcept { return _mmleq(m2,m1); }
3784  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _mmseq(m1,ms); }
3785  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _mmsneq(m1,ms); }
3786  INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _mmsless(m1,ms); }
3787  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _mmsleq(m1,ms); }
3788  INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _msmless(ms,m1); }
3789  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept { return _msmleq(ms,m1); }
3790  INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmseq(m1,m2); }
3791  INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmsneq(m1,m2); }
3792  INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmsless(m1,m2); }
3793  INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmsleq(m1,m2); }
3794  INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmsless(m2,m1); }
3795  INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept { return _msmsleq(m2,m1); }
3796  INLINE bool operator !(const l_imatrix &ms) noexcept { return _mnot(ms); }
3797  INLINE bool operator !(const l_imatrix_slice &ms) noexcept { return _msnot(ms); }
3798  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) noexcept { return _mout(s,r); }
3799  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) noexcept { return _msout(s,r); }
3800  INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) noexcept { return _min(s,r); }
3801  INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) noexcept { return _msin(s,r); }
3802 
3803 } // namespace cxsc
3804 
3805 #endif
3806 
cxsc::mid
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_imatrix_subv::operator&=
l_imatrix_subv & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:972
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
cxsc::l_imatrix_subv::operator+=
l_imatrix_subv & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
Definition: l_imatrix.inl:675
cxsc::l_imatrix::l_imatrix
l_imatrix() noexcept
Constructor of class l_imatrix.
Definition: l_imatrix.inl:31
cxsc::l_imatrix::operator()
l_imatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1252
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
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:47
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
cxsc::Ub
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::l_imatrix_slice::operator+=
l_imatrix_slice & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
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:416
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::l_imatrix_slice::operator/=
l_imatrix_slice & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
Definition: l_imatrix.inl:1553
cxsc::l_imatrix_slice::operator[]
l_imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:348
cxsc::l_imatrix_slice::operator*=
l_imatrix_slice & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:1549
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::l_imatrix_subv::operator*=
l_imatrix_subv & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:674
cxsc::l_imatrix_subv::operator[]
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_imatrix.inl:185
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::l_imatrix_slice::operator()
l_imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1760
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::l_imatrix_subv::operator()
l_imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_imatrix.hpp:436
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::Lb
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::l_imatrix_slice
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1280
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
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:78
cxsc::l_imatrix_slice::operator=
l_imatrix_slice & operator=(const l_imatrix &m) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:522
cxsc::l_imatrix::operator=
l_imatrix & operator=(const l_interval &r) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:496
cxsc::l_imatrix_subv::operator=
l_imatrix_subv & operator=(const l_imatrix_subv &rv) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:428
cxsc::l_imatrix_slice::operator&=
l_imatrix_slice & operator&=(const l_imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:2173
cxsc::l_imatrix_subv::operator/=
l_imatrix_subv & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
Definition: l_imatrix.inl:677
cxsc::diam
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::l_imatrix::operator[]
l_imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:296
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::_imatrix
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cimatrix.inl:1137
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::l_imatrix_slice::operator-=
l_imatrix_slice & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
cxsc::l_imatrix_subv::operator-=
l_imatrix_subv & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
Definition: l_imatrix.inl:676
cxsc::l_imatrix_subv::operator|=
l_imatrix_subv & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:923
cxsc::l_ivector_slice
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::l_ivector_slice::operator=
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::l_ivector::l_ivector
l_ivector() noexcept
Constructor of class l_ivector.
Definition: l_ivector.inl:31
cxsc::l_imatrix_subv
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:47
cxsc::l_interval::l_interval
l_interval() noexcept
Constructor of class l_interval.
Definition: l_interval.inl:45
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::l_ivector::operator=
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
cxsc::l_ivector_slice::operator*=
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
cxsc::l_imatrix_slice::operator|=
l_imatrix_slice & operator|=(const l_imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:2117
cxsc::real
The Scalar Type real.
Definition: real.hpp:114