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