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
29namespace cxsc {
30
31INLINE l_imatrix::l_imatrix() noexcept:dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
32{
33}
34
35INLINE 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
41INLINE 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
47INLINE 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
53INLINE 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
59INLINE 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
66INLINE 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
73INLINE 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
80INLINE 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
87INLINE 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
100INLINE 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
113INLINE 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
124noexcept
125#endif
126{ return _vsvassign(*this,l_ivector(m)); }
127
128
129INLINE 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
136INLINE 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
143INLINE 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
150INLINE 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
157INLINE 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
164INLINE 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
171INLINE 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
178INLINE 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
413INLINE 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); }
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); }
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); }
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); }
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); }
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); }
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); }
1839#if(CXSC_INDEX_CHECK)
1840
1841#else
1842 noexcept
1843#endif
1844 { return _vmslimult<l_rvector,l_imatrix_slice,l_ivector>(v,ms); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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
The Data Type idotprecision.
Definition idot.hpp:48
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix_subv.
Definition imatrix.hpp:56
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
The Data Type ivector_slice.
Definition ivector.hpp:963
The Data Type ivector.
Definition ivector.hpp:55
The Multiple-Precision Data Type l_imatrix_slice.
l_imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
l_imatrix_slice & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
l_imatrix_slice & operator=(const l_imatrix &m) noexcept
Implementation of standard assigning operator.
l_imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
l_imatrix_slice & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
l_imatrix_slice & operator&=(const l_imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
l_imatrix_slice & operator|=(const l_imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
l_imatrix_slice & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
l_imatrix_slice & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
The Multiple-Precision Data Type l_imatrix_subv.
Definition l_imatrix.hpp:47
l_imatrix_subv & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
l_imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
l_imatrix_subv & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
l_imatrix_subv & operator=(const l_imatrix_subv &rv) noexcept
Implementation of standard assigning operator.
l_imatrix_subv & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
l_imatrix_subv & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
l_imatrix_subv & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
l_imatrix_subv & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
The Multiple-Precision Data Type l_imatrix.
l_imatrix & operator=(const l_interval &r) noexcept
Implementation of standard assigning operator.
l_imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
l_imatrix() noexcept
Constructor of class l_imatrix.
Definition l_imatrix.inl:31
l_imatrix & operator()() noexcept
Operator for accessing the whole matrix.
The Multiple-Precision Data Type l_interval.
l_interval() noexcept
Constructor of class l_interval.
The Multiple-Precision Data Type l_ivector_slice.
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
The Multiple-Precision Data Type l_ivector.
Definition l_ivector.hpp:55
l_ivector() noexcept
Constructor of class l_ivector.
Definition l_ivector.inl:31
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
The Multiple-Precision Data Type l_rmatrix_slice.
The Multiple-Precision Data Type l_rmatrix_subv.
Definition l_rmatrix.hpp:47
The Multiple-Precision Data Type l_rmatrix.
The Multiple-Precision Data Type l_rvector_slice.
The Multiple-Precision Data Type l_rvector.
Definition l_rvector.hpp:54
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition cimatrix.inl:242
int ColLen(const cimatrix &)
Returns the column dimension.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition cimatrix.inl:231
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.