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() throw():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) throw():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) throw():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) throw():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) throw():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  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
64 #else
65  throw():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  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
77 #else
78  throw():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) throw():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 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
97 #else
98 throw()
99 #endif
100 { return _vsvassign(*this,l_rvector(m)); }
101 
102 INLINE l_rvector _l_rvector(const rmatrix_subv &rs) throw() { return l_rvector(rs); }
103 
104 INLINE l_rmatrix::l_rmatrix(const l_rvector &v) throw():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) throw():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) throw():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) throw():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  throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
135 #else
136  throw()
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) throw():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) throw():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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
176 #else
177  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
187 #else
188  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
198 #else
199  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
209 #else
210  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
220 #else
221  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
233 #else
234  throw()
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  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
246 #else
247  throw()
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  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
259 #else
260  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
272 #else
273  throw()
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  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
285 #else
286  throw()
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  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
298 #else
299  throw()
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  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
311 #else
312  throw()
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  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
324 #else
325  throw()
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  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
337 #else
338  throw()
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) throw() { return _mvmvassign(*this,rv); }
350  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_real &r) throw() { return _mvsassign(*this,r); }
352 #if(CXSC_INDEX_CHECK)
353  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
354 #else
355  throw()
356 #endif
357  { return _mvvassign(*this,v); }
359 #if(CXSC_INDEX_CHECK)
360  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
361 #else
362  throw()
363 #endif
364  { return _mvvassign(*this,l_rvector(v)); }
365  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvvassign(*this,rvector(rv)); }
366  INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); }
368 #if(CXSC_INDEX_CHECK)
369  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
370 #else
371  throw()
372 #endif
373  { return _mvvassign(*this,v); }
375 #if(CXSC_INDEX_CHECK)
376  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
377 #else
378  throw()
379 #endif
380  { return _mvvassign(*this,l_rvector(v)); }
381  INLINE l_rmatrix &l_rmatrix::operator =(const l_real &r) throw() { return _msassign(*this,r); }
382  INLINE l_rmatrix &l_rmatrix::operator =(const l_rmatrix &m) throw() { 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) throw() { return _mmsassign<l_rmatrix,l_rmatrix_slice,l_real>(*this,ms); }
384  INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector &v) throw() { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,v); }
385  INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector_slice &v) throw() { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,l_rvector(v)); }
386  INLINE l_rmatrix &l_rmatrix::operator =(const real &r) throw() { return _msassign(*this,l_real(r)); }
387  INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix &m) throw() { return _mmassign<l_rmatrix,rmatrix,l_real>(*this,m, l_real(0)); }
388  INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<l_rmatrix,rmatrix_slice,l_real>(*this,ms); }
389  INLINE l_rmatrix &l_rmatrix::operator =(const rvector &v) throw() { return _mvassign<l_rmatrix,rvector,l_real>(*this,v); }
390  INLINE l_rmatrix &l_rmatrix::operator =(const rvector_slice &v) throw() { return _mvassign<l_rmatrix,rvector,l_real>(*this,rvector(v)); }
391 
392  INLINE l_rmatrix::operator void*() throw() { return _mvoid(*this); }
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
396 #else
397  throw()
398 #endif
399  { return _msmassign(*this,m); }
401 #if(CXSC_INDEX_CHECK)
402  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
403 #else
404  throw()
405 #endif
406  { return _msmsassign(*this,ms); }
407  INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_real &r) throw() { return _mssassign(*this,r); }
409 #if(CXSC_INDEX_CHECK)
410  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
411 #else
412  throw()
413 #endif
414  { return _msmassign(*this,l_rmatrix(v)); }
416 #if(CXSC_INDEX_CHECK)
417  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
418 #else
419  throw()
420 #endif
421  { return _msmassign(*this,l_rmatrix(l_rvector(v))); }
423 #if(CXSC_INDEX_CHECK)
424  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
425 #else
426  throw()
427 #endif
428  { return _msmassign(*this,m); }
430 #if(CXSC_INDEX_CHECK)
431  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
432 #else
433  throw()
434 #endif
435  { return _msmsassign(*this,ms); }
436  INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); }
438 #if(CXSC_INDEX_CHECK)
439  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
440 #else
441  throw()
442 #endif
443  { return _msmassign(*this,rmatrix(v)); }
445 #if(CXSC_INDEX_CHECK)
446  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
447 #else
448  throw()
449 #endif
450  { return _msmassign(*this,rmatrix(rvector(v))); }
451  INLINE l_rmatrix_slice::operator void*() throw() { return _msvoid(*this); }
452  INLINE l_rvector operator /(const l_rmatrix_subv &rv, const l_real &s) throw() { 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) throw() { 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) throw() { return _mvsmult<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
455  INLINE l_rmatrix_subv &l_rmatrix_subv::operator *=(const l_real &c) throw() { return _mvsmultassign(*this,c); }
456  INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const l_real &c) throw() { return _mvsplusassign(*this,c); }
457  INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const l_real &c) throw() { return _mvsminusassign(*this,c); }
458  INLINE l_rmatrix_subv &l_rmatrix_subv::operator /=(const l_real &c) throw() { return _mvsdivassign(*this,c); }
459  INLINE l_rvector abs(const l_rmatrix_subv &mv) throw() { return _mvabs<l_rmatrix_subv,l_rvector>(mv); }
460  INLINE l_rvector &l_rvector::operator =(const l_rmatrix_subv &mv) throw() { 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) throw() { 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  throw(OP_WITH_WRONG_DIM)
465 #else
466  throw()
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  throw(OP_WITH_WRONG_DIM)
472 #else
473  throw()
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  throw(OP_WITH_WRONG_DIM)
479 #else
480  throw()
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  throw(OP_WITH_WRONG_DIM)
486 #else
487  throw()
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  throw(OP_WITH_WRONG_DIM)
493 #else
494  throw()
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  throw(OP_WITH_WRONG_DIM)
500 #else
501  throw()
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  throw(OP_WITH_WRONG_DIM)
507 #else
508  throw()
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  throw(OP_WITH_WRONG_DIM)
514 #else
515  throw()
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  throw(OP_WITH_WRONG_DIM)
521 #else
522  throw()
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  throw(OP_WITH_WRONG_DIM)
528 #else
529  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
535 #else
536  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
542 #else
543  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
549 #else
550  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
556 #else
557  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
563 #else
564  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
570 #else
571  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
577 #else
578  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
584 #else
585  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
591 #else
592  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
598 #else
599  throw()
600 #endif
601  { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
603 #if(CXSC_INDEX_CHECK)
604  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
605 #else
606  throw()
607 #endif
608  { return _mvvplusassign(*this,rv); }
610 #if(CXSC_INDEX_CHECK)
611  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
612 #else
613  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
619 #else
620  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
626 #else
627  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
633 #else
634  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
640 #else
641  throw()
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  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
647 #else
648  throw()
649 #endif
650  { return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
652 #if(CXSC_INDEX_CHECK)
653  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
654 #else
655  throw()
656 #endif
657  { return _mvvminusassign(*this,rv); }
659 #if(CXSC_INDEX_CHECK)
660  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
661 #else
662  throw()
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  throw(OP_WITH_WRONG_DIM)
669 #else
670  throw()
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  throw(OP_WITH_WRONG_DIM)
676 #else
677  throw()
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  throw(OP_WITH_WRONG_DIM)
683 #else
684  throw()
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  throw(OP_WITH_WRONG_DIM)
690 #else
691  throw()
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  throw(OP_WITH_WRONG_DIM)
697 #else
698  throw()
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  throw(OP_WITH_WRONG_DIM)
704 #else
705  throw()
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  throw(OP_WITH_WRONG_DIM)
712 #else
713  throw()
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  throw(OP_WITH_WRONG_DIM)
719 #else
720  throw()
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  throw(OP_WITH_WRONG_DIM)
726 #else
727  throw()
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  throw(OP_WITH_WRONG_DIM)
733 #else
734  throw()
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  throw(OP_WITH_WRONG_DIM)
740 #else
741  throw()
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  throw(OP_WITH_WRONG_DIM)
747 #else
748  throw()
749 #endif
750  { _vmvaccu(dp,rvector(sl2),rv1); }
751 
753 #if(CXSC_INDEX_CHECK)
754  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
755 #else
756  throw()
757 #endif
758  { return _mvvplusassign(*this,rv); }
760 #if(CXSC_INDEX_CHECK)
761  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
762 #else
763  throw()
764 #endif
765  { return _mvvplusassign(*this,l_rvector(rv)); }
767 #if(CXSC_INDEX_CHECK)
768  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
769 #else
770  throw()
771 #endif
772  { return _mvvminusassign(*this,rv); }
774 #if(CXSC_INDEX_CHECK)
775  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
776 #else
777  throw()
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) throw() { return rm; }
793  INLINE l_rmatrix _l_rmatrix(const l_rvector &v) throw() { return l_rmatrix(v); }
799  INLINE l_rmatrix _l_rmatrix(const l_rvector_slice &v) throw() { return l_rmatrix(v); }
805  INLINE l_rmatrix _l_rmatrix(const l_real &r) throw() { return l_rmatrix(r); }
806  INLINE int Lb(const l_rmatrix &rm, const int &i)
807 #if(CXSC_INDEX_CHECK)
808  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
809 #else
810  throw()
811 #endif
812  { return _mlb(rm,i); }
813  INLINE int Ub(const l_rmatrix &rm, const int &i)
814 #if(CXSC_INDEX_CHECK)
815  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
816 #else
817  throw()
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  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
823 #else
824  throw()
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  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
830 #else
831  throw()
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  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
837 #else
838  throw()
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  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
844 #else
845  throw()
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) throw() { _mresize(A);}
862  INLINE void Resize(l_rmatrix &A,const int &m, const int &n)
863 #if(CXSC_INDEX_CHECK)
864  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES)
865 #else
866  throw()
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  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES)
872 #else
873  throw()
874 #endif
875  { _mresize<l_rmatrix,l_real>(A,m1,m2,n1,n2); }
876  INLINE l_rmatrix abs(const l_rmatrix &m) throw() { return _mabs<l_rmatrix,l_rmatrix>(m); }
877  INLINE l_rmatrix abs(const l_rmatrix_slice &ms) throw() { return _msabs<l_rmatrix_slice,l_rmatrix>(ms); }
878  INLINE l_real::l_real(const l_rmatrix &m)
879 #if(CXSC_INDEX_CHECK)
880  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ)
881 #else
882  throw()
883 #endif
884  { _smconstr(*this,m); }
885 // INLINE l_real l_real::_l_real(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
886  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix &m) throw() { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
887  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix_slice &ms) throw() { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
888  INLINE l_rmatrix operator *(const l_rmatrix &m,const l_real &c) throw() { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
889  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
890  INLINE l_rmatrix &operator *=(l_rmatrix &m,const l_real &c) throw() { return _msmultassign(m,c); }
892 #if(CXSC_INDEX_CHECK)
893  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
894 #else
895  throw()
896 #endif
897  { return (*this=*this*m); }
899 #if(CXSC_INDEX_CHECK)
900  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
901 #else
902  throw()
903 #endif
904  { return (*this=*this*m); }
905  INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const l_real &c) throw() { return _mssmultassign(*this,c); }
906  INLINE l_rmatrix operator /(const l_rmatrix &m,const l_real &c) throw() { return _msdiv<l_rmatrix,l_real,l_rmatrix>(m,c); }
907  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const l_real &c) throw() { return _mssdiv<l_rmatrix_slice,l_real,l_rmatrix>(ms,c); }
908  INLINE l_rmatrix &operator /=(l_rmatrix &m,const l_real &c) throw() { return _msdivassign(m,c); }
909  INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const l_real &c) throw() { return _mssdivassign(*this,c); }
910  INLINE l_rmatrix operator *(const real &c, const l_rmatrix &m) throw() { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
911  INLINE l_rmatrix operator *(const real &c, const l_rmatrix_slice &ms) throw() { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
912  INLINE l_rmatrix operator *(const l_rmatrix &m,const real &c) throw() { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
913  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const real &c) throw() { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
914  INLINE l_rmatrix &operator *=(l_rmatrix &m,const real &c) throw() { return _msmultassign(m,c); }
916 #if(CXSC_INDEX_CHECK)
917  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
918 #else
919  throw()
920 #endif
921  { return (*this=*this*m); }
923 #if(CXSC_INDEX_CHECK)
924  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
925 #else
926  throw()
927 #endif
928  { return (*this=*this*m); }
929  INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); }
930  INLINE l_rmatrix operator /(const l_rmatrix &m,const real &c) throw() { return _msdiv<l_rmatrix,real,l_rmatrix>(m,c); }
931  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const real &c) throw() { return _mssdiv<l_rmatrix_slice,real,l_rmatrix>(ms,c); }
932  INLINE l_rmatrix &operator /=(l_rmatrix &m,const real &c) throw() { return _msdivassign(m,c); }
933  INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); }
934 // INLINE l_real::l_real(const rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); }
935 // INLINE l_real l_real::_l_real(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
936  INLINE l_rmatrix operator *(const l_real &c, const rmatrix &m) throw() { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
937  INLINE l_rmatrix operator *(const l_real &c, const rmatrix_slice &ms) throw() { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
938  INLINE l_rmatrix operator *(const rmatrix &m,const l_real &c) throw() { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
939  INLINE l_rmatrix operator *(const rmatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
940  INLINE l_rmatrix operator /(const rmatrix &m,const l_real &c) throw() { return _msdiv<rmatrix,l_real,l_rmatrix>(m,c); }
941  INLINE l_rmatrix operator /(const rmatrix_slice &ms, const l_real &c) throw() { 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  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
945 #else
946  throw()
947 #endif
948  { _vmconstr<l_rvector,l_rmatrix,l_real>(*this,sl); }
950 #if(CXSC_INDEX_CHECK)
951  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
952 #else
953  throw()
954 #endif
955  { _vmsconstr<l_rvector,l_rmatrix_slice,l_real>(*this,sl); }
957 #if(CXSC_INDEX_CHECK)
958  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
959 #else
960  throw()
961 #endif
962  { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,m); }
964 #if(CXSC_INDEX_CHECK)
965  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
966 #else
967  throw()
968 #endif
969  { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,l_rmatrix(m)); }
971 #if(CXSC_INDEX_CHECK)
972  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
973 #else
974  throw()
975 #endif
976  { return _vsvassign(*this,l_rvector(l_rmatrix(m))); }
978 #if(CXSC_INDEX_CHECK)
979  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
980 #else
981  throw()
982 #endif
983  { return _mvvassign(*this,l_rvector(m)); }
985 #if(CXSC_INDEX_CHECK)
986  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
987 #else
988  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
994 #else
995  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1001 #else
1002  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1008 #else
1009  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1015 #else
1016  throw()
1017 #endif
1018  { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(v,ms); }
1020 #if(CXSC_INDEX_CHECK)
1021  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1022 #else
1023  throw()
1024 #endif
1025  { return _vmlmultassign<l_rvector,l_rmatrix,l_real>(v,m); }
1027 #if(CXSC_INDEX_CHECK)
1028  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1029 #else
1030  throw()
1031 #endif
1032  { return _vmslmultassign<l_rvector,l_rmatrix_slice,l_real>(v,ms); }
1034 #if(CXSC_INDEX_CHECK)
1035  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1036 #else
1037  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1043 #else
1044  throw()
1045 #endif
1046  { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(l_rvector(v),m); }
1048 #if(CXSC_INDEX_CHECK)
1049  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1050 #else
1051  throw()
1052 #endif
1053  { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(l_rvector(v),m); }
1055 #if(CXSC_INDEX_CHECK)
1056  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
1057 #else
1058  throw()
1059 #endif
1060  { return _mvvassign(*this,rvector(m)); }
1062 #if(CXSC_INDEX_CHECK)
1063  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
1064 #else
1065  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1071 #else
1072  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1078 #else
1079  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1085 #else
1086  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1092 #else
1093  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1099 #else
1100  throw()
1101 #endif
1102  { return _msvlmult<l_rmatrix_slice,rvector,l_rvector>(ms,v); }
1103 
1104  INLINE const l_rmatrix &operator +(const l_rmatrix &m) throw() { return m; }
1105  INLINE l_rmatrix operator +(const l_rmatrix_slice &m) throw() { return l_rmatrix(m); }
1106  INLINE l_rmatrix operator +(const l_rmatrix &m1,const l_rmatrix &m2)
1107 #if(CXSC_INDEX_CHECK)
1108  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1109 #else
1110  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1116 #else
1117  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1123 #else
1124  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1130 #else
1131  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1137 #else
1138  throw()
1139 #endif
1140  { return _mmplusassign(m1,m2); }
1142 #if(CXSC_INDEX_CHECK)
1143  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1144 #else
1145  throw()
1146 #endif
1147  { return _mmsplusassign(m1,ms); }
1149 #if(CXSC_INDEX_CHECK)
1150  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1151 #else
1152  throw()
1153 #endif
1154  { return _msmplusassign(*this,m1); }
1156 #if(CXSC_INDEX_CHECK)
1157  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1158 #else
1159  throw()
1160 #endif
1161  { return _msmsplusassign(*this,ms2); }
1162  INLINE l_rmatrix operator -(const l_rmatrix &m) throw() { return _mminus(m); }
1163  INLINE l_rmatrix operator -(const l_rmatrix_slice &m) throw() { 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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1167 #else
1168  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1174 #else
1175  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1181 #else
1182  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1188 #else
1189  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1195 #else
1196  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1202 #else
1203  throw()
1204 #endif
1205  { return _mmsminusassign(m1,ms); }
1207 #if(CXSC_INDEX_CHECK)
1208  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1209 #else
1210  throw()
1211 #endif
1212  { return _msmminusassign(*this,m1); }
1214 #if(CXSC_INDEX_CHECK)
1215  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1216 #else
1217  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1223 #else
1224  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1230 #else
1231  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1237 #else
1238  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1244 #else
1245  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1251 #else
1252  throw()
1253 #endif
1254  { return _mmlmultassign<l_rmatrix,l_rmatrix,l_real>(m1,m2); }
1256 #if(CXSC_INDEX_CHECK)
1257  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1258 #else
1259  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1265 #else
1266  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1272 #else
1273  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1279 #else
1280  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1286 #else
1287  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1293 #else
1294  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1300 #else
1301  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1307 #else
1308  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1314 #else
1315  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1321 #else
1322  throw()
1323 #endif
1324  { return _mmplusassign(m1,m2); }
1326 #if(CXSC_INDEX_CHECK)
1327  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1328 #else
1329  throw()
1330 #endif
1331  { return _mmsplusassign(m1,ms); }
1333 #if(CXSC_INDEX_CHECK)
1334  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1335 #else
1336  throw()
1337 #endif
1338  { return _msmplusassign(*this,m1); }
1340 #if(CXSC_INDEX_CHECK)
1341  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1342 #else
1343  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1349 #else
1350  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1356 #else
1357  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1363 #else
1364  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1370 #else
1371  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1377 #else
1378  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1384 #else
1385  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1391 #else
1392  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1398 #else
1399  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1405 #else
1406  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1412 #else
1413  throw()
1414 #endif
1415  { return _mmsminusassign(m1,ms); }
1417 #if(CXSC_INDEX_CHECK)
1418  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1419 #else
1420  throw()
1421 #endif
1422  { return _msmminusassign(*this,m1); }
1424 #if(CXSC_INDEX_CHECK)
1425  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1426 #else
1427  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1433 #else
1434  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1440 #else
1441  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1447 #else
1448  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1454 #else
1455  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1461 #else
1462  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1468 #else
1469  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1475 #else
1476  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1482 #else
1483  throw()
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  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1489 #else
1490  throw()
1491 #endif
1492  { return _mmlmultassign<l_rmatrix,rmatrix,l_real>(m1,m2); }
1494 #if(CXSC_INDEX_CHECK)
1495  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
1496 #else
1497  throw()
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) throw() { return _mmeq(m1,m2); }
1501  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmneq(m1,m2); }
1502  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmless(m1,m2); }
1503  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmleq(m1,m2); }
1504  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmless(m2,m1); }
1505  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmleq(m2,m1); }
1506  INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmseq(m1,ms); }
1507  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsneq(m1,ms); }
1508  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsless(m1,ms); }
1509  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsleq(m1,ms); }
1510  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _msmless(ms,m1); }
1511  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _msmleq(ms,m1); }
1512  INLINE bool operator ==(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmseq(m1,m2); }
1513  INLINE bool operator !=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsneq(m1,m2); }
1514  INLINE bool operator <(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsless(m1,m2); }
1515  INLINE bool operator <=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsleq(m1,m2); }
1516  INLINE bool operator >(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsless(m2,m1); }
1517  INLINE bool operator >=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsleq(m2,m1); }
1518  INLINE bool operator !(const l_rmatrix &ms) throw() { return _mnot(ms); }
1519  INLINE bool operator !(const l_rmatrix_slice &ms) throw() { return _msnot(ms); }
1520  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix &r) throw() { return _mout(s,r); }
1521  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix_slice &r) throw() { return _msout(s,r); }
1522  INLINE std::istream &operator >>(std::istream &s,l_rmatrix &r) throw() { return _min(s,r); }
1523  INLINE std::istream &operator >>(std::istream &s,l_rmatrix_slice &r) throw() { return _msin(s,r); }
1524 
1525 } // namespace cxsc
1526 
1527 #endif
1528 
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:999
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
The Data Type idotprecision.
Definition: idot.hpp:47
INLINE l_rvector _l_rvector(const rmatrix_subv &rs)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
Definition: l_rmatrix.inl:102
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
The Data Type dotprecision.
Definition: dot.hpp:111
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:46
l_rmatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
Definition: l_rmatrix.inl:217
l_rmatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: l_rmatrix.hpp:245
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
l_rmatrix_slice & operator/=(const l_real &c)
Implementation of division and allocation operation.
Definition: l_rmatrix.inl:909
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
l_rmatrix_slice & operator-=(const l_rmatrix &m1)
Implementation of subtraction and allocation operation.
Definition: l_rmatrix.inl:1206
l_rmatrix_subv & operator-=(const l_real &c)
Implementation of subtraction and allocation operation.
Definition: l_rmatrix.inl:457
The Data Type rvector_slice.
Definition: rvector.hpp:1063
l_rmatrix_subv & operator*=(const l_real &c)
Implementation of multiplication and allocation operation.
Definition: l_rmatrix.inl:455
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:415
The Data Type rvector.
Definition: rvector.hpp:57
l_rvector_slice & operator*=(const l_real &r)
Implementation of multiplication and allocation operation.
Definition: l_rvector.inl:306
l_rmatrix_subv & operator+=(const l_real &c)
Implementation of addition and allocation operation.
Definition: l_rmatrix.inl:456
l_rmatrix & operator=(const l_real &r)
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:381
l_rmatrix_slice & operator*=(const l_rmatrix &m)
Implementation of multiplication and allocation operation.
Definition: l_rmatrix.inl:891
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
l_rmatrix _l_rmatrix(const l_rmatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
Definition: l_rmatrix.inl:787
The Data Type rmatrix.
Definition: rmatrix.hpp:470
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
l_rmatrix()
Constructor of class l_rmatrix.
Definition: l_rmatrix.inl:31
l_real & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_rmatrix.inl:132
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
l_real(void)
Constructor of class l_real.
Definition: l_real.cpp:174
l_rmatrix_subv & operator/=(const l_real &c)
Implementation of division and allocation operation.
Definition: l_rmatrix.inl:458
l_rmatrix_slice & operator+=(const l_rmatrix &m1)
Implementation of addition and allocation operation.
Definition: l_rmatrix.inl:1148
l_rvector()
Constructor of class l_rvector.
Definition: l_rvector.inl:31
l_rmatrix & operator()()
Operator for accessing the whole matrix.
Definition: l_rmatrix.hpp:972
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
l_rvector_slice & operator=(const l_rvector_slice &sl)
Implementation of standard assigning operator.
Definition: l_rvector.inl:240
l_rmatrix_slice & operator()()
Operator for accessing the whole matrix.
Definition: l_rmatrix.hpp:1436
l_rmatrix_subv & operator=(const l_rmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:349
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Scalar Type real.
Definition: real.hpp:113
l_rmatrix_slice & operator=(const l_rmatrix &m)
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:393
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:744
l_rmatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
Definition: l_rmatrix.inl:269
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
l_rvector & operator=(const l_rvector &rv)
Implementation of standard assigning operator.
Definition: l_rvector.inl:235