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
29namespace cxsc {
30
31INLINE l_rmatrix::l_rmatrix() noexcept:dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
32{
33}
34
35INLINE 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
41INLINE 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
47INLINE 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
54INLINE 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
61INLINE 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
74INLINE 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
87INLINE 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
98noexcept
99#endif
100{ return _vsvassign(*this,l_rvector(m)); }
101
102INLINE l_rvector _l_rvector(const rmatrix_subv &rs) noexcept { return l_rvector(rs); }
103
104INLINE 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
111INLINE 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
118INLINE 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
125INLINE 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
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
334INLINE 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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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.
l_rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
l_rmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
l_rmatrix_slice & operator=(const l_rmatrix &m) noexcept
Implementation of standard assigning operator.
l_rmatrix_slice & operator/=(const l_real &c) noexcept
Implementation of division and allocation operation.
l_rmatrix_slice & operator+=(const l_rmatrix &m1) noexcept
Implementation of addition and allocation operation.
l_rmatrix_slice & operator*=(const l_rmatrix &m) noexcept
Implementation of multiplication and allocation operation.
l_rmatrix_slice & operator-=(const l_rmatrix &m1) noexcept
Implementation of subtraction and allocation operation.
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.
l_rmatrix_subv & operator=(const l_rmatrix_subv &rv) noexcept
Implementation of standard assigning operator.
l_rmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
l_real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
l_rmatrix_subv & operator+=(const l_real &c) noexcept
Implementation of addition and allocation operation.
l_rmatrix_subv & operator/=(const l_real &c) noexcept
Implementation of division and allocation operation.
l_rmatrix_subv & operator-=(const l_real &c) noexcept
Implementation of subtraction and allocation operation.
The Multiple-Precision Data Type l_rmatrix.
l_rmatrix & operator=(const l_real &r) noexcept
Implementation of standard assigning operator.
l_rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
l_rmatrix & operator()() noexcept
Operator for accessing the whole matrix.
l_rmatrix() noexcept
Constructor of class l_rmatrix.
Definition l_rmatrix.inl:31
The Multiple-Precision Data Type l_rvector_slice.
l_rvector_slice & operator=(const l_rvector_slice &sl) noexcept
Implementation of standard assigning operator.
l_rvector_slice & operator*=(const l_real &r) noexcept
Implementation of multiplication and allocation operation.
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.
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition cimatrix.inl:242
int ColLen(const cimatrix &)
Returns the column dimension.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition cimatrix.inl:231
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.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
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.
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.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.