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 
29 namespace cxsc {
30 
31 INLINE cimatrix::cimatrix() noexcept:dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
32 {
33 }
34 
35 INLINE 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 
41 INLINE 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 
47 INLINE 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 
53 INLINE 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 
59 INLINE 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 
66 INLINE 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 
73 INLINE 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 
80 INLINE 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 
87 INLINE 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 
100 INLINE 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 
113 INLINE 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 
120 INLINE 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 
127 INLINE 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 
134 INLINE 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 
141 INLINE 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 
148 INLINE 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 
155 INLINE 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 
162 INLINE 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 
169 INLINE 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 
288  INLINE cinterval& cimatrix_subv::operator [](const int &i)
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 
327  INLINE cimatrix_subv cimatrix::operator [](const int &i)
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 
406  INLINE cimatrix_subv cimatrix_slice::operator [](const int &i) const
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 
472 INLINE 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); }
917  INLINE cinterval operator *(const civector_slice &sl,const cimatrix_subv &sv)
918 #if(CXSC_INDEX_CHECK)
919 
920 #else
921  noexcept
922 #endif
923  { return _vmvcimult<civector,cimatrix_subv,cinterval>(civector(sl),sv); }
924  INLINE cinterval operator *(const cimatrix_subv &mv,const civector_slice &vs)
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 
1725  INLINE civector::civector(const cimatrix &sl)
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); }
1802  INLINE civector &operator *=(civector &v,const cimatrix &m)
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 
3875  INLINE cimatrix cimatrix::operator()(const intvector& p, const intvector& q) {
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 
3898  INLINE cimatrix cimatrix::operator()(const intmatrix& P, const intmatrix& Q) {
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
cxsc::cimatrix_slice::operator=
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
Definition: cimatrix.inl:581
cxsc::cimatrix_slice::operator-=
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cxsc::mid
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::civector_slice
The Data Type civector_slice.
Definition: civector.hpp:1015
cxsc::cinterval::cinterval
cinterval(void) noexcept
Constructor of class cinterval.
Definition: cinterval.hpp:64
cxsc::cimatrix_subv::operator&=
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
Definition: scimatrix.hpp:12894
cxsc::cimatrix_subv::operator[]
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: cimatrix.inl:275
cxsc::civector::operator=
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
Definition: civector.inl:339
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
cxsc::cmatrix
The Data Type cmatrix.
Definition: cmatrix.hpp:514
cxsc::cimatrix_subv::operator|=
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:12794
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::cimatrix_subv::operator+=
cimatrix_subv & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
Definition: cimatrix.inl:734
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
cxsc::Ub
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::cimatrix_subv::operator/=
cimatrix_subv & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:736
cxsc::cimatrix_subv::operator-=
cimatrix_subv & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
Definition: cimatrix.inl:735
cxsc::civector::civector
civector() noexcept
Constructor of class civector.
Definition: civector.inl:31
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:52
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:58
cxsc::civector::operator()
civector & operator()() noexcept
Operator for accessing the whole vector.
Definition: civector.hpp:987
cxsc::cimatrix_slice::operator()
cimatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: cimatrix.hpp:2229
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::cmatrix_slice
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1203
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::cimatrix_slice::operator|=
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:3986
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::Lb
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::civector_slice::operator=
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::cimatrix::cimatrix
cimatrix() noexcept
Constructor of class cimatrix.
Definition: cimatrix.inl:31
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::cimatrix_slice::operator[]
cimatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition: cimatrix.inl:380
cxsc::cimatrix::operator()
cimatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: cimatrix.hpp:1623
cxsc::civector_slice::operator*=
civector_slice & operator*=(const cinterval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: civector.inl:720
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::cimatrix_slice::operator/=
cimatrix_slice & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1624
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::cimatrix_slice::operator+=
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cxsc::cimatrix::operator[]
cimatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: cimatrix.inl:301
cxsc::diam
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::_imatrix
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cimatrix.inl:1137
cxsc::cmatrix_subv
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:54
cxsc::cimatrix_slice::operator&=
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
Definition: scimatrix.hpp:4002
cxsc::cimatrix_slice
The Data Type cimatrix_slice.
Definition: cimatrix.hpp:1651
cxsc::cimatrix::operator=
cimatrix & operator=(const cinterval &r) noexcept
Implementation of standard assigning operator.
Definition: cimatrix.inl:555
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:908
cxsc::cinterval
The Scalar Type cinterval.
Definition: cinterval.hpp:55
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::cimatrix_slice::operator*=
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1620
cxsc::complex
The Scalar Type complex.
Definition: complex.hpp:50
cxsc::cvector_slice
The Data Type cvector_slice.
Definition: cvector.hpp:845
cxsc::civector
The Data Type civector.
Definition: civector.hpp:57
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:314
cxsc::cimatrix_subv::operator*=
cimatrix_subv & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:733
cxsc::cimatrix_subv::operator()
cimatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: cimatrix.hpp:508
cxsc::cimatrix_subv
The Data Type cimatrix_subv.
Definition: cimatrix.hpp:68
cxsc::cimatrix_subv::operator=
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scimatrix.hpp:12874
cxsc::real
The Scalar Type real.
Definition: real.hpp:114