C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_rmatrix.inl
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: l_rmatrix.inl,v 1.21 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LRMATRIX_INL_INCLUDED
27 #define _CXSC_LRMATRIX_INL_INCLUDED
28 
29 namespace cxsc {
30 
31 INLINE l_rmatrix::l_rmatrix() noexcept:dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
32 {
33 }
34 
35 INLINE l_rmatrix::l_rmatrix(const l_real &r) noexcept:lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
36 {
37  dat=new l_real[1];
38  *dat=r;
39 }
40 
41 INLINE l_rmatrix::l_rmatrix(const real &r) noexcept:lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
42 {
43  dat=new l_real[1];
44  *dat=r;
45 }
46 
47 INLINE l_rmatrix::l_rmatrix(const l_rmatrix &rm) noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
48 {
49  dat=new l_real[xsize*ysize];
50  for(int i=0;i<xsize*ysize;i++)
51  dat[i]=rm.dat[i];
52 }
53 
54 INLINE l_rmatrix::l_rmatrix(const rmatrix &rm) noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
55 {
56  dat=new l_real[xsize*ysize];
57  for(int i=0;i<xsize*ysize;i++)
58  dat[i]=rm.dat[i];
59 }
60 
61 INLINE l_rmatrix::l_rmatrix(const int &m, const int &n)
62 #if(CXSC_INDEX_CHECK)
63 :lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
64 #else
65  noexcept:lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
66 #endif
67 {
68 #if(CXSC_INDEX_CHECK)
69  if((n<0)||(m<0)) cxscthrow(ERROR_LRMATRIX_WRONG_BOUNDARIES("l_rmatrix::l_rmatrix(const int &m, const int &n)"));
70 #endif
71  dat=new l_real[m*n];
72 }
73 
74 INLINE l_rmatrix::l_rmatrix(const int &m1, const int &m2, const int &n1, const int &n2)
75 #if(CXSC_INDEX_CHECK)
76 :lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
77 #else
78  noexcept:lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
79 #endif
80 {
81 #if(CXSC_INDEX_CHECK)
82  if((m2<m1)||(n2<n1)) cxscthrow(ERROR_LRMATRIX_WRONG_BOUNDARIES("l_rmatrix::l_rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
83 #endif
84  dat=new l_real[xsize*ysize];
85 }
86 
87 INLINE l_rvector::l_rvector(const l_rmatrix_subv &v) noexcept:l(v.lb),u(v.ub),size(v.size)
88 {
89  dat=new l_real[size];
90  for (int i=0, j=v.start;i<v.size;i++,j+=v.offset)
91  dat[i]=v.dat[j];
92 }
93 
95 #if(CXSC_INDEX_CHECK)
96 
97 #else
98 noexcept
99 #endif
100 { return _vsvassign(*this,l_rvector(m)); }
101 
102 INLINE l_rvector _l_rvector(const rmatrix_subv &rs) noexcept { return l_rvector(rs); }
103 
104 INLINE l_rmatrix::l_rmatrix(const l_rvector &v) noexcept:lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
105 {
106  dat=new l_real[v.size];
107  for(int i=0;i<v.size;i++)
108  dat[i]=v.dat[i];
109 }
110 
111 INLINE l_rmatrix::l_rmatrix(const rvector &v) noexcept:lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
112 {
113  dat=new l_real[v.size];
114  for(int i=0;i<v.size;i++)
115  dat[i]=v.dat[i];
116 }
117 
118 INLINE l_rmatrix::l_rmatrix(const l_rvector_slice &v) noexcept:lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
119 {
120  dat=new l_real[v.size];
121  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
122  dat[i]=v.dat[j];
123 }
124 
125 INLINE l_rmatrix::l_rmatrix(const rvector_slice &v) noexcept:lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
126 {
127  dat=new l_real[v.size];
128  for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
129  dat[i]=v.dat[j];
130 }
131 
132  INLINE l_real &l_rmatrix_subv::operator [](const int &i) const
133 #if(CXSC_INDEX_CHECK)
134 
135 #else
136  noexcept
137 #endif
138  {
139 #if(CXSC_INDEX_CHECK)
140  if((i<lb)||(i>ub)) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC("l_real &l_rmatrix_subv::operator [](const int &i)"));
141 #endif
142  return dat[start+((i-lb)*offset)];
143  }
144 
145  INLINE l_rmatrix::l_rmatrix(const l_rmatrix_slice &sl) noexcept:lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
146  {
147  int i,j;
148 
149  dat=new l_real[xsize*ysize];
150  for (i=0;i<ysize;i++)
151  {
152  for(j=0;j<xsize;j++)
153  {
154  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
155  }
156  }
157  }
158 
159  INLINE l_rmatrix::l_rmatrix(const rmatrix_slice &sl) noexcept:lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
160  {
161  int i,j;
162 
163  dat=new l_real[xsize*ysize];
164  for (i=0;i<ysize;i++)
165  {
166  for(j=0;j<xsize;j++)
167  {
168  dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
169  }
170  }
171  }
172 
173  INLINE l_rmatrix_subv Row(l_rmatrix &m,const int &i)
174 #if(CXSC_INDEX_CHECK)
175 
176 #else
177  noexcept
178 #endif
179 
180  {
181  return m[i];
182  }
183 
184  INLINE l_rmatrix_subv Col(l_rmatrix &m,const int &i)
185 #if(CXSC_INDEX_CHECK)
186 
187 #else
188  noexcept
189 #endif
190 
191  {
192  return m[Col(i)];
193  }
194 
195  INLINE l_rmatrix_subv Row(const l_rmatrix &m,const int &i)
196 #if(CXSC_INDEX_CHECK)
197 
198 #else
199  noexcept
200 #endif
201 
202  {
203  return m[i];
204  }
205 
206  INLINE l_rmatrix_subv Col(const l_rmatrix &m,const int &i)
207 #if(CXSC_INDEX_CHECK)
208 
209 #else
210  noexcept
211 #endif
212 
213  {
214  return m[Col(i)];
215  }
216 
217  INLINE l_rmatrix_subv l_rmatrix::operator [](const int &i) const
218 #if(CXSC_INDEX_CHECK)
219 
220 #else
221  noexcept
222 #endif
223  {
224 #if(CXSC_INDEX_CHECK)
225  if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix::operator [](const int &i)"));
226 #endif
227  return l_rmatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
228  }
229 
230  INLINE l_rmatrix_subv l_rmatrix::operator [](const cxscmatrix_column &i) const
231 #if(CXSC_INDEX_CHECK)
232 
233 #else
234  noexcept
235 #endif
236  {
237 #if(CXSC_INDEX_CHECK)
238  if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix::operator [](const cxscmatrix_column &i)"));
239 #endif
240  return l_rmatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
241  }
242 
243  INLINE l_rmatrix_slice l_rmatrix::operator ()(const int &m, const int &n)
244 #if(CXSC_INDEX_CHECK)
245 
246 #else
247  noexcept
248 #endif
249  {
250 #if(CXSC_INDEX_CHECK)
251  if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix::operator ()(const int &m, const int &n)"));
252 #endif
253  return l_rmatrix_slice(*this,1,m,1,n);
254  }
255 
256  INLINE l_rmatrix_slice l_rmatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
257 #if(CXSC_INDEX_CHECK)
258 
259 #else
260  noexcept
261 #endif
262  {
263 #if(CXSC_INDEX_CHECK)
264  if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
265 #endif
266  return l_rmatrix_slice(*this,m1,m2,n1,n2);
267  }
268 
269  INLINE l_rmatrix_subv l_rmatrix_slice::operator [](const int &i) const
270 #if(CXSC_INDEX_CHECK)
271 
272 #else
273  noexcept
274 #endif
275  {
276 #if(CXSC_INDEX_CHECK)
277  if((i<start1)||(i>end1)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix_slice::operator [](const int &i)"));
278 #endif
279  return l_rmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
280  }
281 
282  INLINE l_rmatrix_subv l_rmatrix_slice::operator [](const cxscmatrix_column &i) const
283 #if(CXSC_INDEX_CHECK)
284 
285 #else
286  noexcept
287 #endif
288  {
289 #if(CXSC_INDEX_CHECK)
290  if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix_slice::operator [](const cxscmatrix_column &i)"));
291 #endif
292  return l_rmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
293  }
294 
295  INLINE l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m, const int &n)
296 #if(CXSC_INDEX_CHECK)
297 
298 #else
299  noexcept
300 #endif
301  {
302 #if(CXSC_INDEX_CHECK)
303  if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m, const int &n)"));
304 #endif
305  return l_rmatrix_slice(*this,1,m,1,n);
306  }
307 
308  INLINE l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
309 #if(CXSC_INDEX_CHECK)
310 
311 #else
312  noexcept
313 #endif
314  {
315 #if(CXSC_INDEX_CHECK)
316  if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
317 #endif
318  return l_rmatrix_slice(*this,m1,m2,n1,n2);
319  }
320 
322 #if(CXSC_INDEX_CHECK)
323 
324 #else
325  noexcept
326 #endif
327 {
328 #if(CXSC_INDEX_CHECK)
329  if(1<lb||i>ub) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i)"));
330 #endif
331  return l_rmatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
332 }
333 
334 INLINE l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i1,const int &i2)
335 #if(CXSC_INDEX_CHECK)
336 
337 #else
338  noexcept
339 #endif
340 {
341 #if(CXSC_INDEX_CHECK)
342  if(i1<lb||i2>ub) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i1,const int &i2)"));
343 #endif
344  return l_rmatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
345 }
346 
347 
348 
349  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rmatrix_subv &rv) noexcept { return _mvmvassign(*this,rv); }
350  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_real &r) noexcept { return _mvsassign(*this,r); }
352 #if(CXSC_INDEX_CHECK)
353 
354 #else
355  noexcept
356 #endif
357  { return _mvvassign(*this,v); }
359 #if(CXSC_INDEX_CHECK)
360 
361 #else
362  noexcept
363 #endif
364  { return _mvvassign(*this,l_rvector(v)); }
365  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rmatrix_subv &rv) noexcept { return _mvvassign(*this,rvector(rv)); }
366  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const real &r) noexcept { return _mvsassign(*this,r); }
368 #if(CXSC_INDEX_CHECK)
369 
370 #else
371  noexcept
372 #endif
373  { return _mvvassign(*this,v); }
375 #if(CXSC_INDEX_CHECK)
376 
377 #else
378  noexcept
379 #endif
380  { return _mvvassign(*this,l_rvector(v)); }
381  INLINE l_rmatrix &l_rmatrix::operator =(const l_real &r) noexcept { return _msassign(*this,r); }
382  INLINE l_rmatrix &l_rmatrix::operator =(const l_rmatrix &m) noexcept { return _mmassign<l_rmatrix,l_rmatrix,l_real>(*this,m, l_real(0)); }
383  INLINE l_rmatrix &l_rmatrix::operator =(const l_rmatrix_slice &ms) noexcept { return _mmsassign<l_rmatrix,l_rmatrix_slice,l_real>(*this,ms); }
384  INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector &v) noexcept { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,v); }
385  INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector_slice &v) noexcept { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,l_rvector(v)); }
386  INLINE l_rmatrix &l_rmatrix::operator =(const real &r) noexcept { return _msassign(*this,l_real(r)); }
387  INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix &m) noexcept { return _mmassign<l_rmatrix,rmatrix,l_real>(*this,m, l_real(0)); }
388  INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix_slice &ms) noexcept { return _mmsassign<l_rmatrix,rmatrix_slice,l_real>(*this,ms); }
389  INLINE l_rmatrix &l_rmatrix::operator =(const rvector &v) noexcept { return _mvassign<l_rmatrix,rvector,l_real>(*this,v); }
390  INLINE l_rmatrix &l_rmatrix::operator =(const rvector_slice &v) noexcept { return _mvassign<l_rmatrix,rvector,l_real>(*this,rvector(v)); }
391 
392  INLINE l_rmatrix::operator void*() noexcept { return _mvoid(*this); }
394 #if(CXSC_INDEX_CHECK)
395 
396 #else
397  noexcept
398 #endif
399  { return _msmassign(*this,m); }
401 #if(CXSC_INDEX_CHECK)
402 
403 #else
404  noexcept
405 #endif
406  { return _msmsassign(*this,ms); }
407  INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_real &r) noexcept { return _mssassign(*this,r); }
409 #if(CXSC_INDEX_CHECK)
410 
411 #else
412  noexcept
413 #endif
414  { return _msmassign(*this,l_rmatrix(v)); }
416 #if(CXSC_INDEX_CHECK)
417 
418 #else
419  noexcept
420 #endif
421  { return _msmassign(*this,l_rmatrix(l_rvector(v))); }
423 #if(CXSC_INDEX_CHECK)
424 
425 #else
426  noexcept
427 #endif
428  { return _msmassign(*this,m); }
430 #if(CXSC_INDEX_CHECK)
431 
432 #else
433  noexcept
434 #endif
435  { return _msmsassign(*this,ms); }
436  INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const real &r) noexcept { return _mssassign(*this,r); }
438 #if(CXSC_INDEX_CHECK)
439 
440 #else
441  noexcept
442 #endif
443  { return _msmassign(*this,rmatrix(v)); }
445 #if(CXSC_INDEX_CHECK)
446 
447 #else
448  noexcept
449 #endif
450  { return _msmassign(*this,rmatrix(rvector(v))); }
451  INLINE l_rmatrix_slice::operator void*() noexcept { return _msvoid(*this); }
452  INLINE l_rvector operator /(const l_rmatrix_subv &rv, const l_real &s) noexcept { return _mvsdiv<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
453  INLINE l_rvector operator *(const l_rmatrix_subv &rv, const l_real &s) noexcept { return _mvsmult<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
454  INLINE l_rvector operator *(const l_real &s, const l_rmatrix_subv &rv) noexcept { return _mvsmult<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
455  INLINE l_rmatrix_subv &l_rmatrix_subv::operator *=(const l_real &c) noexcept { return _mvsmultassign(*this,c); }
456  INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const l_real &c) noexcept { return _mvsplusassign(*this,c); }
457  INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const l_real &c) noexcept { return _mvsminusassign(*this,c); }
458  INLINE l_rmatrix_subv &l_rmatrix_subv::operator /=(const l_real &c) noexcept { return _mvsdivassign(*this,c); }
459  INLINE l_rvector abs(const l_rmatrix_subv &mv) noexcept { return _mvabs<l_rmatrix_subv,l_rvector>(mv); }
460  INLINE l_rvector &l_rvector::operator =(const l_rmatrix_subv &mv) noexcept { return _vmvassign<l_rvector,l_rmatrix_subv,l_real>(*this,mv); }
461  INLINE l_rvector_slice &l_rvector_slice::operator =(const l_rmatrix_subv &mv) noexcept { return _vsvassign(*this,l_rvector(mv)); }
462  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
463 #if(CXSC_INDEX_CHECK)
464 
465 #else
466  noexcept
467 #endif
468  { _mvmvaccu(dp,rv1,rv2); }
469  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
470 #if(CXSC_INDEX_CHECK)
471 
472 #else
473  noexcept
474 #endif
475  { _vmvaccu(dp,rv1,rv2); }
476  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
477 #if(CXSC_INDEX_CHECK)
478 
479 #else
480  noexcept
481 #endif
482  { _vmvaccu(dp,rv2,rv1); }
483  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
484 #if(CXSC_INDEX_CHECK)
485 
486 #else
487  noexcept
488 #endif
489  { _vmvaccu(dp,l_rvector(sl1),rv2); }
490  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
491 #if(CXSC_INDEX_CHECK)
492 
493 #else
494  noexcept
495 #endif
496  { _vmvaccu(dp,l_rvector(sl2),rv1); }
497  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
498 #if(CXSC_INDEX_CHECK)
499 
500 #else
501  noexcept
502 #endif
503  { _mvmvaccu(dp,rv1,rv2); }
504  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
505 #if(CXSC_INDEX_CHECK)
506 
507 #else
508  noexcept
509 #endif
510  { _vmvaccu(dp,rv1,rv2); }
511  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
512 #if(CXSC_INDEX_CHECK)
513 
514 #else
515  noexcept
516 #endif
517  { _vmvaccu(dp,rv2,rv1); }
518  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
519 #if(CXSC_INDEX_CHECK)
520 
521 #else
522  noexcept
523 #endif
524  { _vmvaccu(dp,l_rvector(sl1),rv2); }
525  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
526 #if(CXSC_INDEX_CHECK)
527 
528 #else
529  noexcept
530 #endif
531  { _vmvaccu(dp,l_rvector(sl2),rv1); }
532  INLINE l_real operator *(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
533 #if(CXSC_INDEX_CHECK)
534 
535 #else
536  noexcept
537 #endif
538  { return _mvmvlmult<l_rmatrix_subv,l_rmatrix_subv,l_real>(rv1,rv2); }
539  INLINE l_real operator *(const l_rvector & rv1, const l_rmatrix_subv &rv2)
540 #if(CXSC_INDEX_CHECK)
541 
542 #else
543  noexcept
544 #endif
545  { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv1,rv2); }
546  INLINE l_real operator *(const l_rmatrix_subv &rv1,const l_rvector &rv2)
547 #if(CXSC_INDEX_CHECK)
548 
549 #else
550  noexcept
551 #endif
552  { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv2,rv1); }
553  INLINE l_real operator *(const l_rvector_slice &sl,const l_rmatrix_subv &sv)
554 #if(CXSC_INDEX_CHECK)
555 
556 #else
557  noexcept
558 #endif
559  { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(l_rvector(sl),sv); }
560  INLINE l_real operator *(const l_rmatrix_subv &mv,const l_rvector_slice &vs)
561 #if(CXSC_INDEX_CHECK)
562 
563 #else
564  noexcept
565 #endif
566  { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(l_rvector(vs),mv); }
567  INLINE l_rvector operator +(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
568 #if(CXSC_INDEX_CHECK)
569 
570 #else
571  noexcept
572 #endif
573  { return _mvmvplus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
574  INLINE l_rvector operator +(const l_rmatrix_subv &rv1,const l_rvector &rv2)
575 #if(CXSC_INDEX_CHECK)
576 
577 #else
578  noexcept
579 #endif
580  { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
581  INLINE l_rvector operator +(const l_rvector & rv1, const l_rmatrix_subv &rv2)
582 #if(CXSC_INDEX_CHECK)
583 
584 #else
585  noexcept
586 #endif
587  { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv2,rv1); }
588  INLINE l_rvector operator +(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
589 #if(CXSC_INDEX_CHECK)
590 
591 #else
592  noexcept
593 #endif
594  { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
595  INLINE l_rvector operator +(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
596 #if(CXSC_INDEX_CHECK)
597 
598 #else
599  noexcept
600 #endif
601  { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
603 #if(CXSC_INDEX_CHECK)
604 
605 #else
606  noexcept
607 #endif
608  { return _mvvplusassign(*this,rv); }
610 #if(CXSC_INDEX_CHECK)
611 
612 #else
613  noexcept
614 #endif
615  { return _mvvplusassign(*this,l_rvector(rv)); }
616  INLINE l_rvector operator -(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
617 #if(CXSC_INDEX_CHECK)
618 
619 #else
620  noexcept
621 #endif
622  { return _mvmvminus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
623  INLINE l_rvector operator -(const l_rvector & rv1, const l_rmatrix_subv &rv2)
624 #if(CXSC_INDEX_CHECK)
625 
626 #else
627  noexcept
628 #endif
629  { return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(rv1,rv2); }
630  INLINE l_rvector operator -(const l_rmatrix_subv &rv1,const l_rvector &rv2)
631 #if(CXSC_INDEX_CHECK)
632 
633 #else
634  noexcept
635 #endif
636  { return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
637  INLINE l_rvector operator -(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
638 #if(CXSC_INDEX_CHECK)
639 
640 #else
641  noexcept
642 #endif
643  { return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(l_rvector(sl),mv); }
644  INLINE l_rvector operator -(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
645 #if(CXSC_INDEX_CHECK)
646 
647 #else
648  noexcept
649 #endif
650  { return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
652 #if(CXSC_INDEX_CHECK)
653 
654 #else
655  noexcept
656 #endif
657  { return _mvvminusassign(*this,rv); }
659 #if(CXSC_INDEX_CHECK)
660 
661 #else
662  noexcept
663 #endif
664  { return _mvvminusassign(*this,l_rvector(rv)); }
665 // real
666  INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
667 #if(CXSC_INDEX_CHECK)
668 
669 #else
670  noexcept
671 #endif
672  { _mvmvaccu(dp,rv1,rv2); }
673  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
674 #if(CXSC_INDEX_CHECK)
675 
676 #else
677  noexcept
678 #endif
679  { _mvmvaccu(dp,rv2,rv1); }
680  INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
681 #if(CXSC_INDEX_CHECK)
682 
683 #else
684  noexcept
685 #endif
686  { _vmvaccu(dp,rv1,rv2); }
687  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
688 #if(CXSC_INDEX_CHECK)
689 
690 #else
691  noexcept
692 #endif
693  { _vmvaccu(dp,rv2,rv1); }
694  INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rmatrix_subv &rv2)
695 #if(CXSC_INDEX_CHECK)
696 
697 #else
698  noexcept
699 #endif
700  { _vmvaccu(dp,rvector(sl1),rv2); }
701  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &sl2)
702 #if(CXSC_INDEX_CHECK)
703 
704 #else
705  noexcept
706 #endif
707  { _vmvaccu(dp,rvector(sl2),rv1); }
708 
709  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
710 #if(CXSC_INDEX_CHECK)
711 
712 #else
713  noexcept
714 #endif
715  { _mvmvaccu(dp,rv1,rv2); }
716  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
717 #if(CXSC_INDEX_CHECK)
718 
719 #else
720  noexcept
721 #endif
722  { _mvmvaccu(dp,rv2,rv1); }
723  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
724 #if(CXSC_INDEX_CHECK)
725 
726 #else
727  noexcept
728 #endif
729  { _vmvaccu(dp,rv1,rv2); }
730  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
731 #if(CXSC_INDEX_CHECK)
732 
733 #else
734  noexcept
735 #endif
736  { _vmvaccu(dp,rv2,rv1); }
737  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rmatrix_subv &rv2)
738 #if(CXSC_INDEX_CHECK)
739 
740 #else
741  noexcept
742 #endif
743  { _vmvaccu(dp,rvector(sl1),rv2); }
744  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &sl2)
745 #if(CXSC_INDEX_CHECK)
746 
747 #else
748  noexcept
749 #endif
750  { _vmvaccu(dp,rvector(sl2),rv1); }
751 
753 #if(CXSC_INDEX_CHECK)
754 
755 #else
756  noexcept
757 #endif
758  { return _mvvplusassign(*this,rv); }
760 #if(CXSC_INDEX_CHECK)
761 
762 #else
763  noexcept
764 #endif
765  { return _mvvplusassign(*this,l_rvector(rv)); }
767 #if(CXSC_INDEX_CHECK)
768 
769 #else
770  noexcept
771 #endif
772  { return _mvvminusassign(*this,rv); }
774 #if(CXSC_INDEX_CHECK)
775 
776 #else
777  noexcept
778 #endif
779  { return _mvvminusassign(*this,rvector(rv)); }
780 
781 // l_rmatrix x l_rmatrix
787  INLINE l_rmatrix _l_rmatrix(const l_rmatrix &rm) noexcept { return rm; }
793  INLINE l_rmatrix _l_rmatrix(const l_rvector &v) noexcept { return l_rmatrix(v); }
799  INLINE l_rmatrix _l_rmatrix(const l_rvector_slice &v) noexcept { return l_rmatrix(v); }
805  INLINE l_rmatrix _l_rmatrix(const l_real &r) noexcept { return l_rmatrix(r); }
806  INLINE int Lb(const l_rmatrix &rm, const int &i)
807 #if(CXSC_INDEX_CHECK)
808 
809 #else
810  noexcept
811 #endif
812  { return _mlb(rm,i); }
813  INLINE int Ub(const l_rmatrix &rm, const int &i)
814 #if(CXSC_INDEX_CHECK)
815 
816 #else
817  noexcept
818 #endif
819  { return _mub(rm,i); }
820  INLINE int Lb(const l_rmatrix_slice &rm, const int &i)
821 #if(CXSC_INDEX_CHECK)
822 
823 #else
824  noexcept
825 #endif
826  { return _mslb(rm,i); }
827  INLINE int Ub(const l_rmatrix_slice &rm, const int &i)
828 #if(CXSC_INDEX_CHECK)
829 
830 #else
831  noexcept
832 #endif
833  { return _msub(rm,i); }
834  INLINE l_rmatrix &SetLb(l_rmatrix &m, const int &i,const int &j)
835 #if(CXSC_INDEX_CHECK)
836 
837 #else
838  noexcept
839 #endif
840  { return _msetlb(m,i,j); }
841  INLINE l_rmatrix &SetUb(l_rmatrix &m, const int &i,const int &j)
842 #if(CXSC_INDEX_CHECK)
843 
844 #else
845  noexcept
846 #endif
847  { return _msetub(m,i,j); }
848 
849  INLINE int RowLen ( const l_rmatrix& A ) // Length of the rows of a matrix
850  { return Ub(A,2)-Lb(A,2)+1; } //-------------------------------
851 
852  INLINE int ColLen ( const l_rmatrix& A ) // Length of the columns of a matrix
853  { return Ub(A,1)-Lb(A,1)+1; } //----------------------------------
854 
855  INLINE int RowLen ( const l_rmatrix_slice& A ) // Length of the rows of a matrix
856  { return Ub(A,2)-Lb(A,2)+1; } //-------------------------------
857 
858  INLINE int ColLen ( const l_rmatrix_slice& A ) // Length of the columns of a matrix
859  { return Ub(A,1)-Lb(A,1)+1; } //----------------------------------
860 
861  INLINE void Resize(l_rmatrix &A) noexcept { _mresize(A);}
862  INLINE void Resize(l_rmatrix &A,const int &m, const int &n)
863 #if(CXSC_INDEX_CHECK)
864 
865 #else
866  noexcept
867 #endif
868  { _mresize<l_rmatrix,l_real>(A,m,n); }
869  INLINE void Resize(l_rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
870 #if(CXSC_INDEX_CHECK)
871 
872 #else
873  noexcept
874 #endif
875  { _mresize<l_rmatrix,l_real>(A,m1,m2,n1,n2); }
876  INLINE l_rmatrix abs(const l_rmatrix &m) noexcept { return _mabs<l_rmatrix,l_rmatrix>(m); }
877  INLINE l_rmatrix abs(const l_rmatrix_slice &ms) noexcept { return _msabs<l_rmatrix_slice,l_rmatrix>(ms); }
878  INLINE l_real::l_real(const l_rmatrix &m)
879 #if(CXSC_INDEX_CHECK)
880 
881 #else
882  noexcept
883 #endif
884  { _smconstr(*this,m); }
885 // INLINE l_real l_real::_l_real(const l_rmatrix &m) { _smconstr(*this,m); return *this; }
886  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix &m) noexcept { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
887  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix_slice &ms) noexcept { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
888  INLINE l_rmatrix operator *(const l_rmatrix &m,const l_real &c) noexcept { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
889  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const l_real &c) noexcept { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
890  INLINE l_rmatrix &operator *=(l_rmatrix &m,const l_real &c) noexcept { return _msmultassign(m,c); }
892 #if(CXSC_INDEX_CHECK)
893 
894 #else
895  noexcept
896 #endif
897  { return (*this=*this*m); }
899 #if(CXSC_INDEX_CHECK)
900 
901 #else
902  noexcept
903 #endif
904  { return (*this=*this*m); }
905  INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const l_real &c) noexcept { return _mssmultassign(*this,c); }
906  INLINE l_rmatrix operator /(const l_rmatrix &m,const l_real &c) noexcept { return _msdiv<l_rmatrix,l_real,l_rmatrix>(m,c); }
907  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const l_real &c) noexcept { return _mssdiv<l_rmatrix_slice,l_real,l_rmatrix>(ms,c); }
908  INLINE l_rmatrix &operator /=(l_rmatrix &m,const l_real &c) noexcept { return _msdivassign(m,c); }
909  INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const l_real &c) noexcept { return _mssdivassign(*this,c); }
910  INLINE l_rmatrix operator *(const real &c, const l_rmatrix &m) noexcept { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
911  INLINE l_rmatrix operator *(const real &c, const l_rmatrix_slice &ms) noexcept { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
912  INLINE l_rmatrix operator *(const l_rmatrix &m,const real &c) noexcept { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
913  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const real &c) noexcept { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
914  INLINE l_rmatrix &operator *=(l_rmatrix &m,const real &c) noexcept { return _msmultassign(m,c); }
916 #if(CXSC_INDEX_CHECK)
917 
918 #else
919  noexcept
920 #endif
921  { return (*this=*this*m); }
923 #if(CXSC_INDEX_CHECK)
924 
925 #else
926  noexcept
927 #endif
928  { return (*this=*this*m); }
929  INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const real &c) noexcept { return _mssmultassign(*this,c); }
930  INLINE l_rmatrix operator /(const l_rmatrix &m,const real &c) noexcept { return _msdiv<l_rmatrix,real,l_rmatrix>(m,c); }
931  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const real &c) noexcept { return _mssdiv<l_rmatrix_slice,real,l_rmatrix>(ms,c); }
932  INLINE l_rmatrix &operator /=(l_rmatrix &m,const real &c) noexcept { return _msdivassign(m,c); }
933  INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const real &c) noexcept { return _mssdivassign(*this,c); }
934 // INLINE l_real::l_real(const rmatrix &m) { _smconstr(*this,m); }
935 // INLINE l_real l_real::_l_real(const l_rmatrix &m) { _smconstr(*this,m); return *this; }
936  INLINE l_rmatrix operator *(const l_real &c, const rmatrix &m) noexcept { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
937  INLINE l_rmatrix operator *(const l_real &c, const rmatrix_slice &ms) noexcept { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
938  INLINE l_rmatrix operator *(const rmatrix &m,const l_real &c) noexcept { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
939  INLINE l_rmatrix operator *(const rmatrix_slice &ms,const l_real &c) noexcept { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
940  INLINE l_rmatrix operator /(const rmatrix &m,const l_real &c) noexcept { return _msdiv<rmatrix,l_real,l_rmatrix>(m,c); }
941  INLINE l_rmatrix operator /(const rmatrix_slice &ms, const l_real &c) noexcept { return _mssdiv<rmatrix_slice,l_real,l_rmatrix>(ms,c); }
942  INLINE l_rvector::l_rvector(const l_rmatrix &sl)
943 #if(CXSC_INDEX_CHECK)
944 
945 #else
946  noexcept
947 #endif
948  { _vmconstr<l_rvector,l_rmatrix,l_real>(*this,sl); }
950 #if(CXSC_INDEX_CHECK)
951 
952 #else
953  noexcept
954 #endif
955  { _vmsconstr<l_rvector,l_rmatrix_slice,l_real>(*this,sl); }
957 #if(CXSC_INDEX_CHECK)
958 
959 #else
960  noexcept
961 #endif
962  { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,m); }
964 #if(CXSC_INDEX_CHECK)
965 
966 #else
967  noexcept
968 #endif
969  { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,l_rmatrix(m)); }
971 #if(CXSC_INDEX_CHECK)
972 
973 #else
974  noexcept
975 #endif
976  { return _vsvassign(*this,l_rvector(l_rmatrix(m))); }
978 #if(CXSC_INDEX_CHECK)
979 
980 #else
981  noexcept
982 #endif
983  { return _mvvassign(*this,l_rvector(m)); }
985 #if(CXSC_INDEX_CHECK)
986 
987 #else
988  noexcept
989 #endif
990  { return _mvvassign(*this,l_rvector(l_rmatrix(m))); }
991  INLINE l_rvector operator *(const l_rmatrix &m,const l_rvector &v)
992 #if(CXSC_INDEX_CHECK)
993 
994 #else
995  noexcept
996 #endif
997  { return _mvlmult<l_rmatrix,l_rvector,l_rvector>(m,v); }
998  INLINE l_rvector operator *(const l_rmatrix_slice &ms,const l_rvector &v)
999 #if(CXSC_INDEX_CHECK)
1000 
1001 #else
1002  noexcept
1003 #endif
1004  { return _msvlmult<l_rmatrix_slice,l_rvector,l_rvector>(ms,v); }
1005  INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix &m)
1006 #if(CXSC_INDEX_CHECK)
1007 
1008 #else
1009  noexcept
1010 #endif
1011  { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(v,m); }
1012  INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix_slice &ms)
1013 #if(CXSC_INDEX_CHECK)
1014 
1015 #else
1016  noexcept
1017 #endif
1018  { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(v,ms); }
1020 #if(CXSC_INDEX_CHECK)
1021 
1022 #else
1023  noexcept
1024 #endif
1025  { return _vmlmultassign<l_rvector,l_rmatrix,l_real>(v,m); }
1027 #if(CXSC_INDEX_CHECK)
1028 
1029 #else
1030  noexcept
1031 #endif
1032  { return _vmslmultassign<l_rvector,l_rmatrix_slice,l_real>(v,ms); }
1034 #if(CXSC_INDEX_CHECK)
1035 
1036 #else
1037  noexcept
1038 #endif
1039  { return _vsmlmultassign<l_rvector_slice,l_rmatrix,l_real>(*this,m); }
1040  INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix &m)
1041 #if(CXSC_INDEX_CHECK)
1042 
1043 #else
1044  noexcept
1045 #endif
1046  { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(l_rvector(v),m); }
1048 #if(CXSC_INDEX_CHECK)
1049 
1050 #else
1051  noexcept
1052 #endif
1053  { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(l_rvector(v),m); }
1055 #if(CXSC_INDEX_CHECK)
1056 
1057 #else
1058  noexcept
1059 #endif
1060  { return _mvvassign(*this,rvector(m)); }
1062 #if(CXSC_INDEX_CHECK)
1063 
1064 #else
1065  noexcept
1066 #endif
1067  { return _mvvassign(*this,rvector(rmatrix(m))); }
1068  INLINE l_rvector operator *(const rvector &v,const l_rmatrix &m)
1069 #if(CXSC_INDEX_CHECK)
1070 
1071 #else
1072  noexcept
1073 #endif
1074  { return _vmlmult<rvector,l_rmatrix,l_rvector>(v,m); }
1075  INLINE l_rvector operator *(const rvector &v,const l_rmatrix_slice &ms)
1076 #if(CXSC_INDEX_CHECK)
1077 
1078 #else
1079  noexcept
1080 #endif
1081  { return _vmslmult<rvector,l_rmatrix_slice,l_rvector>(v,ms); }
1082  INLINE l_rvector operator *(const rvector_slice &v,const l_rmatrix &m)
1083 #if(CXSC_INDEX_CHECK)
1084 
1085 #else
1086  noexcept
1087 #endif
1088  { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(l_rvector(v),m); }
1089  INLINE l_rvector operator *(const l_rmatrix &m,const rvector &v)
1090 #if(CXSC_INDEX_CHECK)
1091 
1092 #else
1093  noexcept
1094 #endif
1095  { return _mvlmult<l_rmatrix,rvector,l_rvector>(m,v); }
1096  INLINE l_rvector operator *(const l_rmatrix_slice &ms,const rvector &v)
1097 #if(CXSC_INDEX_CHECK)
1098 
1099 #else
1100  noexcept
1101 #endif
1102  { return _msvlmult<l_rmatrix_slice,rvector,l_rvector>(ms,v); }
1103 
1104  INLINE const l_rmatrix &operator +(const l_rmatrix &m) noexcept { return m; }
1105  INLINE l_rmatrix operator +(const l_rmatrix_slice &m) noexcept { return l_rmatrix(m); }
1106  INLINE l_rmatrix operator +(const l_rmatrix &m1,const l_rmatrix &m2)
1107 #if(CXSC_INDEX_CHECK)
1108 
1109 #else
1110  noexcept
1111 #endif
1112  { return _mmplus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1113  INLINE l_rmatrix operator +(const l_rmatrix &m,const l_rmatrix_slice &ms)
1114 #if(CXSC_INDEX_CHECK)
1115 
1116 #else
1117  noexcept
1118 #endif
1119  { return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1120  INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const l_rmatrix &m)
1121 #if(CXSC_INDEX_CHECK)
1122 
1123 #else
1124  noexcept
1125 #endif
1126  { return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1127  INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2)
1128 #if(CXSC_INDEX_CHECK)
1129 
1130 #else
1131  noexcept
1132 #endif
1133  { return _msmsplus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
1134  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix &m2)
1135 #if(CXSC_INDEX_CHECK)
1136 
1137 #else
1138  noexcept
1139 #endif
1140  { return _mmplusassign(m1,m2); }
1142 #if(CXSC_INDEX_CHECK)
1143 
1144 #else
1145  noexcept
1146 #endif
1147  { return _mmsplusassign(m1,ms); }
1149 #if(CXSC_INDEX_CHECK)
1150 
1151 #else
1152  noexcept
1153 #endif
1154  { return _msmplusassign(*this,m1); }
1156 #if(CXSC_INDEX_CHECK)
1157 
1158 #else
1159  noexcept
1160 #endif
1161  { return _msmsplusassign(*this,ms2); }
1162  INLINE l_rmatrix operator -(const l_rmatrix &m) noexcept { return _mminus(m); }
1163  INLINE l_rmatrix operator -(const l_rmatrix_slice &m) noexcept { return _msminus<l_rmatrix_slice,l_rmatrix>(m); }
1164  INLINE l_rmatrix operator -(const l_rmatrix &m1,const l_rmatrix &m2)
1165 #if(CXSC_INDEX_CHECK)
1166 
1167 #else
1168  noexcept
1169 #endif
1170  { return _mmminus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1171  INLINE l_rmatrix operator -(const l_rmatrix &m,const l_rmatrix_slice &ms)
1172 #if(CXSC_INDEX_CHECK)
1173 
1174 #else
1175  noexcept
1176 #endif
1177  { return _mmsminus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1178  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const l_rmatrix &m)
1179 #if(CXSC_INDEX_CHECK)
1180 
1181 #else
1182  noexcept
1183 #endif
1184  { return _msmminus<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
1185  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
1186 #if(CXSC_INDEX_CHECK)
1187 
1188 #else
1189  noexcept
1190 #endif
1191  { return _msmsminus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1192  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix &m2)
1193 #if(CXSC_INDEX_CHECK)
1194 
1195 #else
1196  noexcept
1197 #endif
1198  { return _mmminusassign(m1,m2); }
1199  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix_slice &ms)
1200 #if(CXSC_INDEX_CHECK)
1201 
1202 #else
1203  noexcept
1204 #endif
1205  { return _mmsminusassign(m1,ms); }
1207 #if(CXSC_INDEX_CHECK)
1208 
1209 #else
1210  noexcept
1211 #endif
1212  { return _msmminusassign(*this,m1); }
1214 #if(CXSC_INDEX_CHECK)
1215 
1216 #else
1217  noexcept
1218 #endif
1219  { return _msmsminusassign(*this,ms2); }
1220  INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix &m2)
1221 #if(CXSC_INDEX_CHECK)
1222 
1223 #else
1224  noexcept
1225 #endif
1226  { return _mmlmult<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1227  INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix_slice &ms)
1228 #if(CXSC_INDEX_CHECK)
1229 
1230 #else
1231  noexcept
1232 #endif
1233  { return _mmslmult<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
1234  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const l_rmatrix &m1)
1235 #if(CXSC_INDEX_CHECK)
1236 
1237 #else
1238  noexcept
1239 #endif
1240  { return _msmlmult<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
1241  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
1242 #if(CXSC_INDEX_CHECK)
1243 
1244 #else
1245  noexcept
1246 #endif
1247  { return _msmslmult<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1248  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix &m2)
1249 #if(CXSC_INDEX_CHECK)
1250 
1251 #else
1252  noexcept
1253 #endif
1254  { return _mmlmultassign<l_rmatrix,l_rmatrix,l_real>(m1,m2); }
1256 #if(CXSC_INDEX_CHECK)
1257 
1258 #else
1259  noexcept
1260 #endif
1261  { return _mmslmultassign<l_rmatrix,l_rmatrix_slice,l_real>(m1,ms); }
1262  INLINE l_rmatrix operator +(const rmatrix &m1,const l_rmatrix &m2)
1263 #if(CXSC_INDEX_CHECK)
1264 
1265 #else
1266  noexcept
1267 #endif
1268  { return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1269  INLINE l_rmatrix operator +(const l_rmatrix &m1,const rmatrix &m2)
1270 #if(CXSC_INDEX_CHECK)
1271 
1272 #else
1273  noexcept
1274 #endif
1275  { return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m2,m1); }
1276  INLINE l_rmatrix operator +(const rmatrix &m,const l_rmatrix_slice &ms)
1277 #if(CXSC_INDEX_CHECK)
1278 
1279 #else
1280  noexcept
1281 #endif
1282  { return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1283  INLINE l_rmatrix operator +(const l_rmatrix &m,const rmatrix_slice &ms)
1284 #if(CXSC_INDEX_CHECK)
1285 
1286 #else
1287  noexcept
1288 #endif
1289  { return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1290  INLINE l_rmatrix operator +(const rmatrix_slice &ms,const l_rmatrix &m)
1291 #if(CXSC_INDEX_CHECK)
1292 
1293 #else
1294  noexcept
1295 #endif
1296  { return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1297  INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const rmatrix &m)
1298 #if(CXSC_INDEX_CHECK)
1299 
1300 #else
1301  noexcept
1302 #endif
1303  { return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1304  INLINE l_rmatrix operator +(const rmatrix_slice &m1,const l_rmatrix_slice &m2)
1305 #if(CXSC_INDEX_CHECK)
1306 
1307 #else
1308  noexcept
1309 #endif
1310  { return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
1311  INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const rmatrix_slice &m2)
1312 #if(CXSC_INDEX_CHECK)
1313 
1314 #else
1315  noexcept
1316 #endif
1317  { return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m2,m1); }
1318  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix &m2)
1319 #if(CXSC_INDEX_CHECK)
1320 
1321 #else
1322  noexcept
1323 #endif
1324  { return _mmplusassign(m1,m2); }
1326 #if(CXSC_INDEX_CHECK)
1327 
1328 #else
1329  noexcept
1330 #endif
1331  { return _mmsplusassign(m1,ms); }
1333 #if(CXSC_INDEX_CHECK)
1334 
1335 #else
1336  noexcept
1337 #endif
1338  { return _msmplusassign(*this,m1); }
1340 #if(CXSC_INDEX_CHECK)
1341 
1342 #else
1343  noexcept
1344 #endif
1345  { return _msmsplusassign(*this,ms2); }
1346  INLINE l_rmatrix operator -(const rmatrix &m1,const l_rmatrix &m2)
1347 #if(CXSC_INDEX_CHECK)
1348 
1349 #else
1350  noexcept
1351 #endif
1352  { return _mmminus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1353  INLINE l_rmatrix operator -(const l_rmatrix &m1,const rmatrix &m2)
1354 #if(CXSC_INDEX_CHECK)
1355 
1356 #else
1357  noexcept
1358 #endif
1359  { return _mmminus<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
1360  INLINE l_rmatrix operator -(const rmatrix &m,const l_rmatrix_slice &ms)
1361 #if(CXSC_INDEX_CHECK)
1362 
1363 #else
1364  noexcept
1365 #endif
1366  { return _mmsminus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1367  INLINE l_rmatrix operator -(const l_rmatrix &m,const rmatrix_slice &ms)
1368 #if(CXSC_INDEX_CHECK)
1369 
1370 #else
1371  noexcept
1372 #endif
1373  { return _mmsminus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1374  INLINE l_rmatrix operator -(const rmatrix_slice &ms,const l_rmatrix &m)
1375 #if(CXSC_INDEX_CHECK)
1376 
1377 #else
1378  noexcept
1379 #endif
1380  { return _msmminus<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
1381  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const rmatrix &m)
1382 #if(CXSC_INDEX_CHECK)
1383 
1384 #else
1385  noexcept
1386 #endif
1387  { return _msmminus<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m); }
1388  INLINE l_rmatrix operator -(const rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
1389 #if(CXSC_INDEX_CHECK)
1390 
1391 #else
1392  noexcept
1393 #endif
1394  { return _msmsminus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1395  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const rmatrix_slice &ms2)
1396 #if(CXSC_INDEX_CHECK)
1397 
1398 #else
1399  noexcept
1400 #endif
1401  { return _msmsminus<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
1402  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix &m2)
1403 #if(CXSC_INDEX_CHECK)
1404 
1405 #else
1406  noexcept
1407 #endif
1408  { return _mmminusassign(m1,m2); }
1409  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix_slice &ms)
1410 #if(CXSC_INDEX_CHECK)
1411 
1412 #else
1413  noexcept
1414 #endif
1415  { return _mmsminusassign(m1,ms); }
1417 #if(CXSC_INDEX_CHECK)
1418 
1419 #else
1420  noexcept
1421 #endif
1422  { return _msmminusassign(*this,m1); }
1424 #if(CXSC_INDEX_CHECK)
1425 
1426 #else
1427  noexcept
1428 #endif
1429  { return _msmsminusassign(*this,ms2); }
1430  INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix &m2)
1431 #if(CXSC_INDEX_CHECK)
1432 
1433 #else
1434  noexcept
1435 #endif
1436  { return _mmlmult<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1437  INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix &m2)
1438 #if(CXSC_INDEX_CHECK)
1439 
1440 #else
1441  noexcept
1442 #endif
1443  { return _mmlmult<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
1444  INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix_slice &ms)
1445 #if(CXSC_INDEX_CHECK)
1446 
1447 #else
1448  noexcept
1449 #endif
1450  { return _mmslmult<rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
1451  INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix_slice &ms)
1452 #if(CXSC_INDEX_CHECK)
1453 
1454 #else
1455  noexcept
1456 #endif
1457  { return _mmslmult<l_rmatrix,rmatrix_slice,l_rmatrix>(m1,ms); }
1458  INLINE l_rmatrix operator *(const rmatrix_slice &ms, const l_rmatrix &m1)
1459 #if(CXSC_INDEX_CHECK)
1460 
1461 #else
1462  noexcept
1463 #endif
1464  { return _msmlmult<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
1465  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const rmatrix &m1)
1466 #if(CXSC_INDEX_CHECK)
1467 
1468 #else
1469  noexcept
1470 #endif
1471  { return _msmlmult<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m1); }
1472  INLINE l_rmatrix operator *(const rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
1473 #if(CXSC_INDEX_CHECK)
1474 
1475 #else
1476  noexcept
1477 #endif
1478  { return _msmslmult<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1479  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const rmatrix_slice &ms2)
1480 #if(CXSC_INDEX_CHECK)
1481 
1482 #else
1483  noexcept
1484 #endif
1485  { return _msmslmult<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
1486  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix &m2)
1487 #if(CXSC_INDEX_CHECK)
1488 
1489 #else
1490  noexcept
1491 #endif
1492  { return _mmlmultassign<l_rmatrix,rmatrix,l_real>(m1,m2); }
1494 #if(CXSC_INDEX_CHECK)
1495 
1496 #else
1497  noexcept
1498 #endif
1499  { return _mmslmultassign<l_rmatrix,rmatrix_slice,l_real>(m1,ms); }
1500  INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmeq(m1,m2); }
1501  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmneq(m1,m2); }
1502  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmless(m1,m2); }
1503  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmleq(m1,m2); }
1504  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmless(m2,m1); }
1505  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix &m2) noexcept { return _mmleq(m2,m1); }
1506  INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _mmseq(m1,ms); }
1507  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _mmsneq(m1,ms); }
1508  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _mmsless(m1,ms); }
1509  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _mmsleq(m1,ms); }
1510  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _msmless(ms,m1); }
1511  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix_slice &ms) noexcept { return _msmleq(ms,m1); }
1512  INLINE bool operator ==(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmseq(m1,m2); }
1513  INLINE bool operator !=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmsneq(m1,m2); }
1514  INLINE bool operator <(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmsless(m1,m2); }
1515  INLINE bool operator <=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmsleq(m1,m2); }
1516  INLINE bool operator >(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmsless(m2,m1); }
1517  INLINE bool operator >=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) noexcept { return _msmsleq(m2,m1); }
1518  INLINE bool operator !(const l_rmatrix &ms) noexcept { return _mnot(ms); }
1519  INLINE bool operator !(const l_rmatrix_slice &ms) noexcept { return _msnot(ms); }
1520  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix &r) noexcept { return _mout(s,r); }
1521  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix_slice &r) noexcept { return _msout(s,r); }
1522  INLINE std::istream &operator >>(std::istream &s,l_rmatrix &r) noexcept { return _min(s,r); }
1523  INLINE std::istream &operator >>(std::istream &s,l_rmatrix_slice &r) noexcept { return _msin(s,r); }
1524 
1525 } // namespace cxsc
1526 
1527 #endif
1528 
The Data Type dotprecision.
Definition: dot.hpp:112
The Data Type idotprecision.
Definition: idot.hpp:48
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
l_real(void) noexcept
Constructor of class l_real.
Definition: l_real.cpp:174
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
l_rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: l_rmatrix.inl:269
l_rmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_rmatrix.hpp:1436
l_rmatrix_slice & operator=(const l_rmatrix &m) noexcept
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:393
l_rmatrix_slice & operator/=(const l_real &c) noexcept
Implementation of division and allocation operation.
Definition: l_rmatrix.inl:909
l_rmatrix_slice & operator+=(const l_rmatrix &m1) noexcept
Implementation of addition and allocation operation.
Definition: l_rmatrix.inl:1148
l_rmatrix_slice & operator*=(const l_rmatrix &m) noexcept
Implementation of multiplication and allocation operation.
Definition: l_rmatrix.inl:891
l_rmatrix_slice & operator-=(const l_rmatrix &m1) noexcept
Implementation of subtraction and allocation operation.
Definition: l_rmatrix.inl:1206
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
l_rmatrix_subv & operator*=(const l_real &c) noexcept
Implementation of multiplication and allocation operation.
Definition: l_rmatrix.inl:455
l_rmatrix_subv & operator=(const l_rmatrix_subv &rv) noexcept
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:349
l_rmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_rmatrix.hpp:245
l_real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_rmatrix.inl:132
l_rmatrix_subv & operator+=(const l_real &c) noexcept
Implementation of addition and allocation operation.
Definition: l_rmatrix.inl:456
l_rmatrix_subv & operator/=(const l_real &c) noexcept
Implementation of division and allocation operation.
Definition: l_rmatrix.inl:458
l_rmatrix_subv & operator-=(const l_real &c) noexcept
Implementation of subtraction and allocation operation.
Definition: l_rmatrix.inl:457
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
l_rmatrix & operator=(const l_real &r) noexcept
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:381
l_rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: l_rmatrix.inl:217
l_rmatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_rmatrix.hpp:972
l_rmatrix() noexcept
Constructor of class l_rmatrix.
Definition: l_rmatrix.inl:31
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
l_rvector_slice & operator=(const l_rvector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: l_rvector.inl:240
l_rvector_slice & operator*=(const l_real &r) noexcept
Implementation of multiplication and allocation operation.
Definition: l_rvector.inl:306
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
l_rvector() noexcept
Constructor of class l_rvector.
Definition: l_rvector.inl:31
l_rvector & operator=(const l_rvector &rv) noexcept
Implementation of standard assigning operator.
Definition: l_rvector.inl:235
The Scalar Type real.
Definition: real.hpp:114
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
The Data Type rmatrix.
Definition: rmatrix.hpp:471
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
INLINE l_rvector _l_rvector(const rmatrix_subv &rs) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: l_rmatrix.inl:102
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
l_rmatrix _l_rmatrix(const l_rmatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: l_rmatrix.inl:787
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623