26#ifndef _CXSC_LRMATRIX_INL_INCLUDED
27#define _CXSC_LRMATRIX_INL_INCLUDED
49 dat=
new l_real[xsize*ysize];
50 for(
int i=0;i<xsize*ysize;i++)
56 dat=
new l_real[xsize*ysize];
57 for(
int i=0;i<xsize*ysize;i++)
63:lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
65 noexcept:lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
69 if((n<0)||(m<0)) cxscthrow(ERROR_LRMATRIX_WRONG_BOUNDARIES(
"l_rmatrix::l_rmatrix(const int &m, const int &n)"));
76:lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
78 noexcept:lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
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)"));
84 dat=
new l_real[xsize*ysize];
90 for (
int i=0, j=v.start;i<v.size;i++,j+=v.offset)
100{
return _vsvassign(*
this,
l_rvector(m)); }
107 for(
int i=0;i<v.size;i++)
114 for(
int i=0;i<v.size;i++)
121 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
128 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
140 if((i<lb)||(i>ub)) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC(
"l_real &l_rmatrix_subv::operator [](const int &i)"));
142 return dat[start+((i-lb)*offset)];
149 dat=
new l_real[xsize*ysize];
150 for (i=0;i<ysize;i++)
154 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
163 dat=
new l_real[xsize*ysize];
164 for (i=0;i<ysize;i++)
168 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
225 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_rmatrix_subv l_rmatrix::operator [](const int &i)"));
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)"));
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)"));
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)"));
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)"));
279 return l_rmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
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)"));
292 return l_rmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
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)"));
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)"));
329 if(1<lb||i>ub) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG(
"l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i)"));
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)"));
344 return l_rmatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
357 {
return _mvvassign(*
this,v); }
364 {
return _mvvassign(*
this,
l_rvector(v)); }
373 {
return _mvvassign(*
this,v); }
380 {
return _mvvassign(*
this,
l_rvector(v)); }
392 INLINE l_rmatrix::operator
void*()
noexcept {
return _mvoid(*
this); }
399 {
return _msmassign(*
this,m); }
406 {
return _msmsassign(*
this,ms); }
414 {
return _msmassign(*
this,
l_rmatrix(v)); }
428 {
return _msmassign(*
this,m); }
435 {
return _msmsassign(*
this,ms); }
443 {
return _msmassign(*
this,
rmatrix(v)); }
451 INLINE l_rmatrix_slice::operator
void*()
noexcept {
return _msvoid(*
this); }
468 { _mvmvaccu(dp,rv1,rv2); }
475 { _vmvaccu(dp,rv1,rv2); }
482 { _vmvaccu(dp,rv2,rv1); }
503 { _mvmvaccu(dp,rv1,rv2); }
510 { _vmvaccu(dp,rv1,rv2); }
517 { _vmvaccu(dp,rv2,rv1); }
538 {
return _mvmvlmult<l_rmatrix_subv,l_rmatrix_subv,l_real>(rv1,rv2); }
545 {
return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv1,rv2); }
552 {
return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv2,rv1); }
559 {
return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(
l_rvector(sl),sv); }
566 {
return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(
l_rvector(vs),mv); }
573 {
return _mvmvplus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
580 {
return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
587 {
return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv2,rv1); }
594 {
return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,
l_rvector(sl)); }
601 {
return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,
l_rvector(sl)); }
608 {
return _mvvplusassign(*
this,rv); }
615 {
return _mvvplusassign(*
this,
l_rvector(rv)); }
622 {
return _mvmvminus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
629 {
return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(rv1,rv2); }
636 {
return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
643 {
return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(
l_rvector(sl),mv); }
650 {
return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(mv,
l_rvector(sl)); }
657 {
return _mvvminusassign(*
this,rv); }
664 {
return _mvvminusassign(*
this,
l_rvector(rv)); }
672 { _mvmvaccu(dp,rv1,rv2); }
679 { _mvmvaccu(dp,rv2,rv1); }
686 { _vmvaccu(dp,rv1,rv2); }
693 { _vmvaccu(dp,rv2,rv1); }
700 { _vmvaccu(dp,
rvector(sl1),rv2); }
707 { _vmvaccu(dp,
rvector(sl2),rv1); }
715 { _mvmvaccu(dp,rv1,rv2); }
722 { _mvmvaccu(dp,rv2,rv1); }
729 { _vmvaccu(dp,rv1,rv2); }
736 { _vmvaccu(dp,rv2,rv1); }
743 { _vmvaccu(dp,
rvector(sl1),rv2); }
750 { _vmvaccu(dp,
rvector(sl2),rv1); }
758 {
return _mvvplusassign(*
this,rv); }
765 {
return _mvvplusassign(*
this,
l_rvector(rv)); }
772 {
return _mvvminusassign(*
this,rv); }
779 {
return _mvvminusassign(*
this,
rvector(rv)); }
812 {
return _mlb(rm,i); }
819 {
return _mub(rm,i); }
826 {
return _mslb(rm,i); }
833 {
return _msub(rm,i); }
840 {
return _msetlb(m,i,j); }
847 {
return _msetub(m,i,j); }
850 {
return Ub(A,2)-
Lb(A,2)+1; }
853 {
return Ub(A,1)-
Lb(A,1)+1; }
856 {
return Ub(A,2)-
Lb(A,2)+1; }
859 {
return Ub(A,1)-
Lb(A,1)+1; }
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)
875 { _mresize<l_rmatrix,l_real>(A,m1,m2,n1,n2); }
884 { _smconstr(*
this,m); }
897 {
return (*
this=*
this*m); }
904 {
return (*
this=*
this*m); }
921 {
return (*
this=*
this*m); }
928 {
return (*
this=*
this*m); }
948 { _vmconstr<l_rvector,l_rmatrix,l_real>(*
this,sl); }
955 { _vmsconstr<l_rvector,l_rmatrix_slice,l_real>(*
this,sl); }
962 {
return _vmassign<l_rvector,l_rmatrix,l_real>(*
this,m); }
969 {
return _vmassign<l_rvector,l_rmatrix,l_real>(*
this,
l_rmatrix(m)); }
983 {
return _mvvassign(*
this,
l_rvector(m)); }
997 {
return _mvlmult<l_rmatrix,l_rvector,l_rvector>(m,v); }
1004 {
return _msvlmult<l_rmatrix_slice,l_rvector,l_rvector>(ms,v); }
1006#if(CXSC_INDEX_CHECK)
1011 {
return _vmlmult<l_rvector,l_rmatrix,l_rvector>(v,m); }
1013#if(CXSC_INDEX_CHECK)
1018 {
return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(v,ms); }
1020#if(CXSC_INDEX_CHECK)
1025 {
return _vmlmultassign<l_rvector,l_rmatrix,l_real>(v,m); }
1027#if(CXSC_INDEX_CHECK)
1032 {
return _vmslmultassign<l_rvector,l_rmatrix_slice,l_real>(v,ms); }
1034#if(CXSC_INDEX_CHECK)
1039 {
return _vsmlmultassign<l_rvector_slice,l_rmatrix,l_real>(*
this,m); }
1041#if(CXSC_INDEX_CHECK)
1046 {
return _vmlmult<l_rvector,l_rmatrix,l_rvector>(
l_rvector(v),m); }
1048#if(CXSC_INDEX_CHECK)
1053 {
return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(
l_rvector(v),m); }
1055#if(CXSC_INDEX_CHECK)
1060 {
return _mvvassign(*
this,
rvector(m)); }
1062#if(CXSC_INDEX_CHECK)
1069#if(CXSC_INDEX_CHECK)
1074 {
return _vmlmult<rvector,l_rmatrix,l_rvector>(v,m); }
1076#if(CXSC_INDEX_CHECK)
1081 {
return _vmslmult<rvector,l_rmatrix_slice,l_rvector>(v,ms); }
1083#if(CXSC_INDEX_CHECK)
1088 {
return _vmlmult<l_rvector,l_rmatrix,l_rvector>(
l_rvector(v),m); }
1090#if(CXSC_INDEX_CHECK)
1095 {
return _mvlmult<l_rmatrix,rvector,l_rvector>(m,v); }
1097#if(CXSC_INDEX_CHECK)
1102 {
return _msvlmult<l_rmatrix_slice,rvector,l_rvector>(ms,v); }
1107#if(CXSC_INDEX_CHECK)
1112 {
return _mmplus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1114#if(CXSC_INDEX_CHECK)
1119 {
return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1121#if(CXSC_INDEX_CHECK)
1126 {
return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1128#if(CXSC_INDEX_CHECK)
1133 {
return _msmsplus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
1135#if(CXSC_INDEX_CHECK)
1140 {
return _mmplusassign(m1,m2); }
1142#if(CXSC_INDEX_CHECK)
1147 {
return _mmsplusassign(m1,ms); }
1149#if(CXSC_INDEX_CHECK)
1154 {
return _msmplusassign(*
this,m1); }
1156#if(CXSC_INDEX_CHECK)
1161 {
return _msmsplusassign(*
this,ms2); }
1165#if(CXSC_INDEX_CHECK)
1170 {
return _mmminus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1172#if(CXSC_INDEX_CHECK)
1177 {
return _mmsminus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1179#if(CXSC_INDEX_CHECK)
1184 {
return _msmminus<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
1186#if(CXSC_INDEX_CHECK)
1191 {
return _msmsminus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1193#if(CXSC_INDEX_CHECK)
1198 {
return _mmminusassign(m1,m2); }
1200#if(CXSC_INDEX_CHECK)
1205 {
return _mmsminusassign(m1,ms); }
1207#if(CXSC_INDEX_CHECK)
1212 {
return _msmminusassign(*
this,m1); }
1214#if(CXSC_INDEX_CHECK)
1219 {
return _msmsminusassign(*
this,ms2); }
1221#if(CXSC_INDEX_CHECK)
1226 {
return _mmlmult<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1228#if(CXSC_INDEX_CHECK)
1233 {
return _mmslmult<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
1235#if(CXSC_INDEX_CHECK)
1240 {
return _msmlmult<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
1242#if(CXSC_INDEX_CHECK)
1247 {
return _msmslmult<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1249#if(CXSC_INDEX_CHECK)
1254 {
return _mmlmultassign<l_rmatrix,l_rmatrix,l_real>(m1,m2); }
1256#if(CXSC_INDEX_CHECK)
1261 {
return _mmslmultassign<l_rmatrix,l_rmatrix_slice,l_real>(m1,ms); }
1263#if(CXSC_INDEX_CHECK)
1268 {
return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1270#if(CXSC_INDEX_CHECK)
1275 {
return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m2,m1); }
1277#if(CXSC_INDEX_CHECK)
1282 {
return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1284#if(CXSC_INDEX_CHECK)
1289 {
return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1291#if(CXSC_INDEX_CHECK)
1296 {
return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1298#if(CXSC_INDEX_CHECK)
1303 {
return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1305#if(CXSC_INDEX_CHECK)
1310 {
return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
1312#if(CXSC_INDEX_CHECK)
1317 {
return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m2,m1); }
1319#if(CXSC_INDEX_CHECK)
1324 {
return _mmplusassign(m1,m2); }
1326#if(CXSC_INDEX_CHECK)
1331 {
return _mmsplusassign(m1,ms); }
1333#if(CXSC_INDEX_CHECK)
1338 {
return _msmplusassign(*
this,m1); }
1340#if(CXSC_INDEX_CHECK)
1345 {
return _msmsplusassign(*
this,ms2); }
1347#if(CXSC_INDEX_CHECK)
1352 {
return _mmminus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1354#if(CXSC_INDEX_CHECK)
1359 {
return _mmminus<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
1361#if(CXSC_INDEX_CHECK)
1366 {
return _mmsminus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
1368#if(CXSC_INDEX_CHECK)
1373 {
return _mmsminus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
1375#if(CXSC_INDEX_CHECK)
1380 {
return _msmminus<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
1382#if(CXSC_INDEX_CHECK)
1387 {
return _msmminus<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m); }
1389#if(CXSC_INDEX_CHECK)
1394 {
return _msmsminus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1396#if(CXSC_INDEX_CHECK)
1401 {
return _msmsminus<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
1403#if(CXSC_INDEX_CHECK)
1408 {
return _mmminusassign(m1,m2); }
1410#if(CXSC_INDEX_CHECK)
1415 {
return _mmsminusassign(m1,ms); }
1417#if(CXSC_INDEX_CHECK)
1422 {
return _msmminusassign(*
this,m1); }
1424#if(CXSC_INDEX_CHECK)
1429 {
return _msmsminusassign(*
this,ms2); }
1431#if(CXSC_INDEX_CHECK)
1436 {
return _mmlmult<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
1438#if(CXSC_INDEX_CHECK)
1443 {
return _mmlmult<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
1445#if(CXSC_INDEX_CHECK)
1450 {
return _mmslmult<rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
1452#if(CXSC_INDEX_CHECK)
1457 {
return _mmslmult<l_rmatrix,rmatrix_slice,l_rmatrix>(m1,ms); }
1459#if(CXSC_INDEX_CHECK)
1464 {
return _msmlmult<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
1466#if(CXSC_INDEX_CHECK)
1471 {
return _msmlmult<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m1); }
1473#if(CXSC_INDEX_CHECK)
1478 {
return _msmslmult<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
1480#if(CXSC_INDEX_CHECK)
1485 {
return _msmslmult<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
1487#if(CXSC_INDEX_CHECK)
1492 {
return _mmlmultassign<l_rmatrix,rmatrix,l_real>(m1,m2); }
1494#if(CXSC_INDEX_CHECK)
1499 {
return _mmslmultassign<l_rmatrix,rmatrix_slice,l_real>(m1,ms); }
1518 INLINE
bool operator !(
const l_rmatrix &ms)
noexcept {
return _mnot(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); }
The Data Type dotprecision.
The Data Type idotprecision.
The Multiple-Precision Data Type l_real.
l_real(void) noexcept
Constructor of class l_real.
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.
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.
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.
l_rvector() noexcept
Constructor of class l_rvector.
l_rvector & operator=(const l_rvector &rv) noexcept
Implementation of standard assigning operator.
The Data Type rmatrix_slice.
The Data Type rmatrix_subv.
The Data Type rvector_slice.
The namespace cxsc, providing all functionality of the class library C-XSC.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
int ColLen(const cimatrix &)
Returns the column dimension.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
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.
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.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
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.