26#ifndef _CXSC_CMATRIX_INL_INCLUDED
27#define _CXSC_CMATRIX_INL_INCLUDED
31INLINE
cmatrix::cmatrix() noexcept:dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
47INLINE
cmatrix::cmatrix(
const cmatrix &rm)
noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
50 for(
int i=0;i<xsize*ysize;i++)
54INLINE
cmatrix::cmatrix(
const rmatrix &rm)
noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.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_CMATRIX_WRONG_BOUNDARIES(
"cmatrix::cmatrix(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_CMATRIX_WRONG_BOUNDARIES(
"cmatrix::cmatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
90 for (
int i=0, j=v.start;i<v.size;i++,j+=v.offset)
97 for(
int i=0;i<v.size;i++)
104 for(
int i=0;i<v.size;i++)
111 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
118 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
128 for (i=0;i<ysize;i++)
132 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
142 for (i=0;i<ysize;i++)
146 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
203 if((i<lb)||(i>ub)) cxscthrow(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC(
"complex &cmatrix_subv::operator [](const int &i) const"));
205 return dat[start+((i-lb)*offset)];
216 if((i<lb)||(i>ub)) cxscthrow(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC(
"complex &cmatrix_subv::operator [](const int &i)"));
218 return dat[start+((i-lb)*offset)];
230 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix::operator [](const int &i)"));
232 return cmatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
243 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix::operator [](const cxscmatrix_column &i)"));
245 return cmatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
256 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix::operator [](const int &i)"));
258 return cmatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
269 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix::operator [](const cxscmatrix_column &i)"));
271 return cmatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
282 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG(
"cmatrix_slice cmatrix::operator ()(const int &m, const int &n)"));
295 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG(
"cmatrix_slice cmatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
308 if((i<start1)||(i>end1)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix_slice::operator [](const int &i)"));
310 return cmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
321 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix_slice::operator [](const cxscmatrix_column &i)"));
323 return cmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
334 if((i<start1)||(i>end1)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix_slice::operator [](const int &i)"));
336 return cmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
347 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cmatrix_subv cmatrix_slice::operator [](const cxscmatrix_column &i)"));
349 return cmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
360 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG(
"cmatrix_slice cmatrix_slice::operator ()(const int &m, const int &n)"));
373 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG(
"cmatrix_slice cmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
386 if(1<lb||i>ub) cxscthrow(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG(
"cmatrix_subv cmatrix_subv::operator ()(const int &i)"));
388 return cmatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
399 if(i1<lb||i2>ub) cxscthrow(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG(
"cmatrix_subv cmatrix_subv::operator ()(const int &i1,const int &i2)"));
401 return cmatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
414 {
return _mvvassign(*
this,v); }
421 {
return _mvvassign(*
this,
cvector(v)); }
430 {
return _mvvassign(*
this,v); }
437 {
return _mvvassign(*
this,
cvector(v)); }
449 INLINE cmatrix::operator
void*()
noexcept {
return _mvoid(*
this); }
456 {
return _msmassign(*
this,m); }
463 {
return _msmsassign(*
this,ms); }
471 {
return _msmassign(*
this,
cmatrix(v)); }
485 {
return _msmassign(*
this,m); }
492 {
return _msmsassign(*
this,ms); }
500 {
return _msmassign(*
this,
rmatrix(v)); }
508 INLINE cmatrix_slice::operator
void*()
noexcept {
return _msvoid(*
this); }
525 {
return _mvvsetim(mv,rv); }
532 {
return _mvvsetre(mv,rv); }
544 {
return _mvmvcmult<cmatrix_subv,cmatrix_subv,complex>(rv1,rv2); }
551 {
return _vmvcmult<cvector,cmatrix_subv,complex>(rv1,rv2); }
558 {
return _vmvcmult<cvector,cmatrix_subv,complex>(rv2,rv1); }
565 {
return _vmvcmult<cvector,cmatrix_subv,complex>(
cvector(sl),sv); }
572 {
return _vmvcmult<cvector,cmatrix_subv,complex>(
cvector(vs),mv); }
579 {
return _mvmvplus<cmatrix_subv,cmatrix_subv,cvector>(rv1,rv2); }
586 {
return _mvvplus<cmatrix_subv,cvector,cvector>(rv1,rv2); }
593 {
return _mvvplus<cmatrix_subv,cvector,cvector>(rv2,rv1); }
600 {
return _mvvplus<cmatrix_subv,cvector,cvector>(mv,
cvector(sl)); }
607 {
return _mvvplus<cmatrix_subv,cvector,cvector>(mv,
cvector(sl)); }
614 {
return _mvvplusassign(*
this,rv); }
621 {
return _mvvplusassign(*
this,
cvector(rv)); }
628 {
return _mvmvminus<cmatrix_subv,cmatrix_subv,cvector>(rv1,rv2); }
635 {
return _vmvminus<cvector,cmatrix_subv,cvector>(rv1,rv2); }
642 {
return _mvvminus<cmatrix_subv,cvector,cvector>(rv1,rv2); }
649 {
return _vmvminus<cvector,cmatrix_subv,cvector>(
cvector(sl),mv); }
656 {
return _mvvminus<cmatrix_subv,cvector,cvector>(mv,
cvector(sl)); }
663 {
return _mvvminusassign(*
this,rv); }
670 {
return _mvvminusassign(*
this,
cvector(rv)); }
679 {
return _mvvplusassign(*
this,rv); }
686 {
return _mvvplusassign(*
this,
cvector(rv)); }
693 {
return _mvvminusassign(*
this,rv); }
700 {
return _mvvminusassign(*
this,
rvector(rv)); }
733 {
return _mlb(rm,i); }
740 {
return _mub(rm,i); }
747 {
return _mslb(rm,i); }
754 {
return _msub(rm,i); }
761 {
return _msetlb(m,i,j); }
768 {
return _msetub(m,i,j); }
771 {
return Ub(A,2)-
Lb(A,2)+1; }
774 {
return Ub(A,1)-
Lb(A,1)+1; }
777 {
return Ub(A,2)-
Lb(A,2)+1; }
780 {
return Ub(A,1)-
Lb(A,1)+1; }
789 { _mresize<cmatrix,complex>(A,m,n); }
790 INLINE
void Resize(
cmatrix &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
796 { _mresize<cmatrix,complex>(A,m1,m2,n1,n2); }
799 INLINE
rmatrix Im(
const cmatrix &m)
noexcept {
return _mim<cmatrix,rmatrix>(m); }
800 INLINE
rmatrix Re(
const cmatrix &m)
noexcept {
return _mre<cmatrix,rmatrix>(m); }
809 {
return _mmsetim<cmatrix,rmatrix>(cm,rm); }
816 {
return _msmsetim<cmatrix_slice,rmatrix>(cm,rm); }
823 {
return _mmssetim<cmatrix,rmatrix_slice>(cm,rm); }
830 {
return _msmssetim<cmatrix_slice,rmatrix_slice>(cm,rm); }
837 {
return _mmsetre<cmatrix,rmatrix>(cm,rm); }
844 {
return _msmsetre<cmatrix_slice,rmatrix>(cm,rm); }
851 {
return _mmssetre<cmatrix,rmatrix_slice>(cm,rm); }
858 {
return _msmssetre<cmatrix_slice,rmatrix_slice>(cm,rm); }
865 { _smconstr(*
this,m); }
878 {
return (*
this=*
this*m); }
885 {
return (*
this=*
this*m); }
902 {
return (*
this=*
this*m); }
909 {
return (*
this=*
this*m); }
929 { _vmconstr<cvector,cmatrix,complex>(*
this,sl); }
936 { _vmsconstr<cvector,cmatrix_slice,complex>(*
this,sl); }
943 {
return _vmassign<cvector,cmatrix,complex>(*
this,m); }
950 {
return _vmassign<cvector,cmatrix,complex>(*
this,
cmatrix(m)); }
964 {
return _mvvassign(*
this,
cvector(m)); }
978 {
return _mvcmult<cmatrix,cvector,cvector>(m,v); }
985 {
return _msvcmult<cmatrix_slice,cvector,cvector>(ms,v); }
992 {
return _vmcmult<cvector,cmatrix,cvector>(v,m); }
999 {
return _vmscmult<cvector,cmatrix_slice,cvector>(v,ms); }
1001#if(CXSC_INDEX_CHECK)
1006 {
return _vmcmultassign<cvector,cmatrix,complex>(v,m); }
1008#if(CXSC_INDEX_CHECK)
1013 {
return _vmscmultassign<cvector,cmatrix_slice,complex>(v,ms); }
1015#if(CXSC_INDEX_CHECK)
1020 {
return _vsmcmultassign<cvector_slice,cmatrix,complex>(*
this,m); }
1022#if(CXSC_INDEX_CHECK)
1027 {
return _vmcmult<cvector,cmatrix,cvector>(
cvector(v),m); }
1029#if(CXSC_INDEX_CHECK)
1034 {
return _vmscmult<cvector,cmatrix_slice,cvector>(
cvector(v),m); }
1036#if(CXSC_INDEX_CHECK)
1041 {
return _mvvassign(*
this,
rvector(m)); }
1043#if(CXSC_INDEX_CHECK)
1050#if(CXSC_INDEX_CHECK)
1055 {
return _vmcmult<rvector,cmatrix,cvector>(v,m); }
1057#if(CXSC_INDEX_CHECK)
1062 {
return _vmscmult<rvector,cmatrix_slice,cvector>(v,ms); }
1064#if(CXSC_INDEX_CHECK)
1069 {
return _vmcmult<cvector,cmatrix,cvector>(
cvector(v),m); }
1071#if(CXSC_INDEX_CHECK)
1076 {
return _mvcmult<cmatrix,rvector,cvector>(m,v); }
1078#if(CXSC_INDEX_CHECK)
1083 {
return _msvcmult<cmatrix_slice,rvector,cvector>(ms,v); }
1088#if(CXSC_INDEX_CHECK)
1093 {
return _mmplus<cmatrix,cmatrix,cmatrix>(m1,m2); }
1095#if(CXSC_INDEX_CHECK)
1100 {
return _mmsplus<cmatrix,cmatrix_slice,cmatrix>(m,ms); }
1102#if(CXSC_INDEX_CHECK)
1107 {
return _mmsplus<cmatrix,cmatrix_slice,cmatrix>(m,ms); }
1109#if(CXSC_INDEX_CHECK)
1114 {
return _msmsplus<cmatrix_slice,cmatrix_slice,cmatrix>(m1,m2); }
1116#if(CXSC_INDEX_CHECK)
1121 {
return _mmplusassign(m1,m2); }
1123#if(CXSC_INDEX_CHECK)
1128 {
return _mmsplusassign(m1,ms); }
1130#if(CXSC_INDEX_CHECK)
1135 {
return _msmplusassign(*
this,m1); }
1137#if(CXSC_INDEX_CHECK)
1142 {
return _msmsplusassign(*
this,ms2); }
1146#if(CXSC_INDEX_CHECK)
1151 {
return _mmminus<cmatrix,cmatrix,cmatrix>(m1,m2); }
1153#if(CXSC_INDEX_CHECK)
1158 {
return _mmsminus<cmatrix,cmatrix_slice,cmatrix>(m,ms); }
1160#if(CXSC_INDEX_CHECK)
1165 {
return _msmminus<cmatrix_slice,cmatrix,cmatrix>(ms,m); }
1167#if(CXSC_INDEX_CHECK)
1172 {
return _msmsminus<cmatrix_slice,cmatrix_slice,cmatrix>(ms1,ms2); }
1174#if(CXSC_INDEX_CHECK)
1179 {
return _mmminusassign(m1,m2); }
1181#if(CXSC_INDEX_CHECK)
1186 {
return _mmsminusassign(m1,ms); }
1188#if(CXSC_INDEX_CHECK)
1193 {
return _msmminusassign(*
this,m1); }
1195#if(CXSC_INDEX_CHECK)
1200 {
return _msmsminusassign(*
this,ms2); }
1202#if(CXSC_INDEX_CHECK)
1207 {
return _mmcmult<cmatrix,cmatrix,cmatrix>(m1,m2); }
1209#if(CXSC_INDEX_CHECK)
1214 {
return _mmscmult<cmatrix,cmatrix_slice,cmatrix>(m1,ms); }
1216#if(CXSC_INDEX_CHECK)
1221 {
return _msmcmult<cmatrix_slice,cmatrix,cmatrix>(ms,m1); }
1223#if(CXSC_INDEX_CHECK)
1228 {
return _msmscmult<cmatrix_slice,cmatrix_slice,cmatrix>(ms1,ms2); }
1230#if(CXSC_INDEX_CHECK)
1235 {
return _mmcmultassign<cmatrix,cmatrix,complex>(m1,m2); }
1237#if(CXSC_INDEX_CHECK)
1242 {
return _mmscmultassign<cmatrix,cmatrix_slice,complex>(m1,ms); }
1244#if(CXSC_INDEX_CHECK)
1249 {
return _mmplus<rmatrix,cmatrix,cmatrix>(m1,m2); }
1251#if(CXSC_INDEX_CHECK)
1256 {
return _mmplus<rmatrix,cmatrix,cmatrix>(m2,m1); }
1258#if(CXSC_INDEX_CHECK)
1263 {
return _mmsplus<rmatrix,cmatrix_slice,cmatrix>(m,ms); }
1265#if(CXSC_INDEX_CHECK)
1270 {
return _mmsplus<cmatrix,rmatrix_slice,cmatrix>(m,ms); }
1272#if(CXSC_INDEX_CHECK)
1277 {
return _mmsplus<cmatrix,rmatrix_slice,cmatrix>(m,ms); }
1279#if(CXSC_INDEX_CHECK)
1284 {
return _mmsplus<rmatrix,cmatrix_slice,cmatrix>(m,ms); }
1286#if(CXSC_INDEX_CHECK)
1291 {
return _msmsplus<rmatrix_slice,cmatrix_slice,cmatrix>(m1,m2); }
1293#if(CXSC_INDEX_CHECK)
1298 {
return _msmsplus<rmatrix_slice,cmatrix_slice,cmatrix>(m2,m1); }
1300#if(CXSC_INDEX_CHECK)
1305 {
return _mmplusassign(m1,m2); }
1307#if(CXSC_INDEX_CHECK)
1312 {
return _mmsplusassign(m1,ms); }
1314#if(CXSC_INDEX_CHECK)
1319 {
return _msmplusassign(*
this,m1); }
1321#if(CXSC_INDEX_CHECK)
1326 {
return _msmsplusassign(*
this,ms2); }
1328#if(CXSC_INDEX_CHECK)
1333 {
return _mmminus<rmatrix,cmatrix,cmatrix>(m1,m2); }
1335#if(CXSC_INDEX_CHECK)
1340 {
return _mmminus<cmatrix,rmatrix,cmatrix>(m1,m2); }
1342#if(CXSC_INDEX_CHECK)
1347 {
return _mmsminus<rmatrix,cmatrix_slice,cmatrix>(m,ms); }
1349#if(CXSC_INDEX_CHECK)
1354 {
return _mmsminus<cmatrix,rmatrix_slice,cmatrix>(m,ms); }
1356#if(CXSC_INDEX_CHECK)
1361 {
return _msmminus<rmatrix_slice,cmatrix,cmatrix>(ms,m); }
1363#if(CXSC_INDEX_CHECK)
1368 {
return _msmminus<cmatrix_slice,rmatrix,cmatrix>(ms,m); }
1370#if(CXSC_INDEX_CHECK)
1375 {
return _msmsminus<rmatrix_slice,cmatrix_slice,cmatrix>(ms1,ms2); }
1377#if(CXSC_INDEX_CHECK)
1382 {
return _msmsminus<cmatrix_slice,rmatrix_slice,cmatrix>(ms1,ms2); }
1384#if(CXSC_INDEX_CHECK)
1389 {
return _mmminusassign(m1,m2); }
1391#if(CXSC_INDEX_CHECK)
1396 {
return _mmsminusassign(m1,ms); }
1398#if(CXSC_INDEX_CHECK)
1403 {
return _msmminusassign(*
this,m1); }
1405#if(CXSC_INDEX_CHECK)
1410 {
return _msmsminusassign(*
this,ms2); }
1412#if(CXSC_INDEX_CHECK)
1417 {
return _mmcmult<rmatrix,cmatrix,cmatrix>(m1,m2); }
1419#if(CXSC_INDEX_CHECK)
1424 {
return _mmcmult<cmatrix,rmatrix,cmatrix>(m1,m2); }
1426#if(CXSC_INDEX_CHECK)
1431 {
return _mmscmult<rmatrix,cmatrix_slice,cmatrix>(m1,ms); }
1433#if(CXSC_INDEX_CHECK)
1438 {
return _mmscmult<cmatrix,rmatrix_slice,cmatrix>(m1,ms); }
1440#if(CXSC_INDEX_CHECK)
1445 {
return _msmcmult<rmatrix_slice,cmatrix,cmatrix>(ms,m1); }
1447#if(CXSC_INDEX_CHECK)
1452 {
return _msmcmult<cmatrix_slice,rmatrix,cmatrix>(ms,m1); }
1454#if(CXSC_INDEX_CHECK)
1459 {
return _msmscmult<rmatrix_slice,cmatrix_slice,cmatrix>(ms1,ms2); }
1461#if(CXSC_INDEX_CHECK)
1466 {
return _msmscmult<cmatrix_slice,rmatrix_slice,cmatrix>(ms1,ms2); }
1468#if(CXSC_INDEX_CHECK)
1473 {
return _mmcmultassign<cmatrix,rmatrix,complex>(m1,m2); }
1475#if(CXSC_INDEX_CHECK)
1480 {
return _mmscmultassign<cmatrix,rmatrix_slice,complex>(m1,ms); }
1481 INLINE
bool operator ==(
const cmatrix &m1,
const cmatrix &m2)
noexcept {
return _mmeq(m1,m2); }
1482 INLINE
bool operator !=(
const cmatrix &m1,
const cmatrix &m2)
noexcept {
return _mmneq(m1,m2); }
1502 INLINE
bool operator !(
const cmatrix &ms)
noexcept {
return _mnot(ms); }
1504 INLINE std::ostream &operator <<(std::ostream &s,
const cmatrix &r)
noexcept {
return _mout(s,r); }
1505 INLINE std::ostream &operator <<(std::ostream &s,
const cmatrix_slice &r)
noexcept {
return _msout(s,r); }
1506 INLINE std::istream &operator >>(std::istream &s,
cmatrix &r)
noexcept {
return _min(s,r); }
1507 INLINE std::istream &operator >>(std::istream &s,
cmatrix_slice &r)
noexcept {
return _msin(s,r); }
1512 for(
int i=0 ; i<
ColLen(A) ; i++)
1513 for(
int j=0 ; j<
RowLen(A) ; j++)
1514 A[i+
Lb(A,1)][j+
Lb(A,2)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)][q[j+
Lb(q)]+
Lb(A,2)];
1521 for(
int i=0 ; i<
ColLen(A) ; i++)
1522 A[i+
Lb(A,1)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)];
1536 return (*
this)(p,q);
The Data Type cmatrix_slice.
cmatrix_slice & operator=(const cmatrix &m) noexcept
Implementation of standard assigning operator.
cmatrix_slice & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
cmatrix_slice & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
cmatrix_slice & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
cmatrix_slice & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
The Data Type cmatrix_subv.
cmatrix_subv & operator=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
cmatrix_subv & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
cmatrix_subv & operator-=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
cmatrix_subv & operator+=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
complex & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
cmatrix_subv & operator*=(const complex &c) noexcept
Implementation of multiplication and allocation operation.
cmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
cmatrix() noexcept
Constructor of class cmatrix.
cmatrix & operator()() noexcept
Operator for accessing the whole matrix.
cmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
cmatrix & operator=(const complex &r) noexcept
Implementation of standard assigning operator.
complex(void) noexcept
Constructor of class complex.
The Data Type cvector_slice.
cvector_slice & operator=(const scvector &sl)
Implementation of standard assigning operator.
cvector_slice & operator*=(const complex &r) noexcept
Implementation of multiplication and allocation operation.
cvector() noexcept
Constructor of class cvector.
cvector & operator=(const cvector &rv) noexcept
Implementation of standard assigning operator.
cvector & operator()() noexcept
Operator for accessing the whole vector.
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.
cmatrix _cmatrix(const cmatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
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.
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.
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.