26 #ifndef _CXSC_LRVECTOR_INL_INCLUDED 27 #define _CXSC_LRVECTOR_INL_INCLUDED 49 throw(ERROR_LRVECTOR_WRONG_BOUNDARIES,ERROR_LRVECTOR_NO_MORE_MEMORY):l(i1),u(i2),size(i2-i1+1)
51 throw():l(i1),u(i2),size(i2-i1+1)
55 if(i1>i2) cxscthrow(ERROR_LRVECTOR_WRONG_BOUNDARIES(
"l_rvector::l_rvector(const int &i1,const int &i2)"));
63 for(
int i=0, j=l-rs.l;i<size;i++,j++)
70 for (
int i=0;i<size;i++)
83 for(
int i=0, j=l-rs.l;i<size;i++,j++)
90 for (
int i=0;i<size;i++)
101 #if(CXSC_INDEX_CHECK) 102 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
107 #if(CXSC_INDEX_CHECK) 108 if(i<l||i>u) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC(
"l_real & l_rvector::operator [](const int &i)"));
114 #if(CXSC_INDEX_CHECK) 115 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
120 #if(CXSC_INDEX_CHECK) 121 if(i<start||i>end) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC(
"l_real & l_rvector_slice::operator [](const int &i)"));
127 #if(CXSC_INDEX_CHECK) 128 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
133 #if(CXSC_INDEX_CHECK) 134 if(1<l||i>u) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG(
"l_rvector_slice l_rvector::operator ()(const int &i)"));
140 #if(CXSC_INDEX_CHECK) 141 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
146 #if(CXSC_INDEX_CHECK) 147 if(i1<l||i2>u) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG(
"l_rvector_slice l_rvector::operator ()(const int &i1,const int &i2)"));
153 #if(CXSC_INDEX_CHECK) 154 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
159 #if(CXSC_INDEX_CHECK) 160 if(1<start||i>end) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG(
"l_rvector_slice l_rvector_slice::operator ()(const int &i)"));
166 #if(CXSC_INDEX_CHECK) 167 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
172 #if(CXSC_INDEX_CHECK) 173 if(i1<start||i2>end) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG(
"l_rvector_slice l_rvector_slice::operator ()(const int &i1,const int &i2)"));
179 #if(CXSC_INDEX_CHECK) 180 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ)
185 #if(CXSC_INDEX_CHECK) 186 if(rv.size>1) cxscthrow(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ(
"l_real::l_real(const l_rvector &rv)"));
187 else if(rv.size<1) cxscthrow(ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ(
"l_real::l_real(const l_rvector &rv)"));
193 #if(CXSC_INDEX_CHECK) 194 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ)
199 #if(CXSC_INDEX_CHECK) 200 if(sl.size>1) cxscthrow(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ(
"l_real::l_real(const l_rvector_slice &sl)"));
201 else if(sl.size<1) cxscthrow(ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ(
"l_real::l_real(const l_rvector_slice &sl)"));
203 *
this=sl.dat[sl.start-sl.l];
239 INLINE l_rvector::operator
void*()
throw() {
return _vvoid(*
this); }
241 #if(CXSC_INDEX_CHECK) 242 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
246 {
return _vsvsassign(*
this,sl); }
248 #if(CXSC_INDEX_CHECK) 249 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
253 {
return _vsvassign(*
this,rv); }
257 #if(CXSC_INDEX_CHECK) 258 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
262 {
return _vsvsassign(*
this,sl); }
264 #if(CXSC_INDEX_CHECK) 265 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
269 {
return _vsvassign(*
this,rv); }
271 INLINE l_rvector_slice::operator
void*()
throw() {
return _vsvoid(*
this); }
278 #if(CXSC_INDEX_CHECK) 279 throw(ERROR__WRONG_BOUNDARIES<l_rvector>)
283 { _vresize<class l_rvector,class l_real>(rv,len); }
285 #if(CXSC_INDEX_CHECK) 286 throw(ERROR__WRONG_BOUNDARIES<l_rvector>)
290 { _vresize<class l_rvector,class l_real>(rv,lb,ub); }
294 INLINE
bool operator !(
const l_rvector &rv)
throw() {
return _vnot(rv); }
338 INLINE std::ostream &operator <<(std::ostream &s,
const l_rvector &rv)
throw() {
return _vout(s,rv); }
339 INLINE std::ostream &operator <<(std::ostream &o,
const l_rvector_slice &sl)
throw() {
return _vsout(o,sl); }
340 INLINE std::istream &operator >>(std::istream &s,
l_rvector &rv)
throw() {
return _vin(s,rv); }
341 INLINE std::istream &operator >>(std::istream &s,
l_rvector_slice &rv)
throw() {
return _vsin(s,rv); }
347 #if(CXSC_INDEX_CHECK) 348 throw(OP_WITH_WRONG_DIM)
352 { _vvaccu(dp,rv1,rv2); }
354 #if(CXSC_INDEX_CHECK) 355 throw(OP_WITH_WRONG_DIM)
359 { _vsvaccu(dp,sl,rv); }
361 #if(CXSC_INDEX_CHECK) 362 throw(OP_WITH_WRONG_DIM)
366 { _vsvaccu(dp,sl,rv); }
367 INLINE
void accumulate(dotprecision &dp,
const l_rvector & rv1,
const l_rmatrix_subv &rv2)
368 #if(CXSC_INDEX_CHECK) 369 throw(OP_WITH_WRONG_DIM)
374 INLINE
void accumulate(dotprecision &dp,
const l_rmatrix_subv & rv1,
const l_rvector &rv2)
375 #if(CXSC_INDEX_CHECK) 376 throw(OP_WITH_WRONG_DIM)
381 INLINE
void accumulate(dotprecision &dp,
const l_rmatrix_subv & rv1,
const l_rmatrix_subv &rv2)
382 #if(CXSC_INDEX_CHECK) 383 throw(OP_WITH_WRONG_DIM)
389 #if(CXSC_INDEX_CHECK) 390 throw(OP_WITH_WRONG_DIM)
394 { _vsvsaccu(dp,sl1,sl2); }
396 #if(CXSC_INDEX_CHECK) 397 throw(OP_WITH_WRONG_DIM)
401 { _vvaccu(dp,rv1,rv2); }
403 #if(CXSC_INDEX_CHECK) 404 throw(OP_WITH_WRONG_DIM)
408 { _vsvaccu(dp,sl,rv); }
410 #if(CXSC_INDEX_CHECK) 411 throw(OP_WITH_WRONG_DIM)
415 { _vsvaccu(dp,sl,rv); }
416 INLINE
void accumulate(idotprecision &dp,
const l_rvector & rv1,
const l_rmatrix_subv &rv2)
417 #if(CXSC_INDEX_CHECK) 418 throw(OP_WITH_WRONG_DIM)
423 INLINE
void accumulate(idotprecision &dp,
const l_rmatrix_subv & rv1,
const l_rvector &rv2)
424 #if(CXSC_INDEX_CHECK) 425 throw(OP_WITH_WRONG_DIM)
430 INLINE
void accumulate(idotprecision &dp,
const l_rmatrix_subv & rv1,
const l_rmatrix_subv &rv2)
431 #if(CXSC_INDEX_CHECK) 432 throw(OP_WITH_WRONG_DIM)
438 #if(CXSC_INDEX_CHECK) 439 throw(OP_WITH_WRONG_DIM)
443 { _vsvsaccu(dp,sl1,sl2); }
447 #if(CXSC_INDEX_CHECK) 448 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
452 {
return _vvlmult<l_rvector,l_rvector,l_real>(rv1,rv2); }
454 #if(CXSC_INDEX_CHECK) 455 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
459 {
return _vsvlmult<l_rvector_slice,l_rvector,l_real>(sl,rv); }
461 #if(CXSC_INDEX_CHECK) 462 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
466 {
return _vsvlmult<l_rvector_slice,l_rvector,l_real>(sl,rv); }
468 #if(CXSC_INDEX_CHECK) 469 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
473 {
return _vsvslmult<l_rvector_slice,l_rvector_slice,l_real>(sl1,sl2); }
478 #if(CXSC_INDEX_CHECK) 479 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
483 {
return _vvplus<l_rvector,l_rvector,l_rvector>(rv1,rv2); }
485 #if(CXSC_INDEX_CHECK) 486 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
490 {
return _vvsplus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
492 #if(CXSC_INDEX_CHECK) 493 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
497 {
return _vvsplus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
499 #if(CXSC_INDEX_CHECK) 500 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
504 {
return _vsvsplus<l_rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
506 #if(CXSC_INDEX_CHECK) 507 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
511 {
return _vvplusassign(rv1,rv2); }
513 #if(CXSC_INDEX_CHECK) 514 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
518 {
return _vvsplusassign(rv,sl); }
520 #if(CXSC_INDEX_CHECK) 521 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
525 {
return _vsvplusassign(*
this,rv); }
527 #if(CXSC_INDEX_CHECK) 528 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
532 {
return _vsvsplusassign(*
this,sl2); }
537 #if(CXSC_INDEX_CHECK) 538 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
542 {
return _vvminus<l_rvector,l_rvector,l_rvector>(rv1,rv2); }
544 #if(CXSC_INDEX_CHECK) 545 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
549 {
return _vvsminus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
551 #if(CXSC_INDEX_CHECK) 552 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
556 {
return _vsvminus<l_rvector_slice,l_rvector,l_rvector>(sl,rv); }
558 #if(CXSC_INDEX_CHECK) 559 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
563 {
return _vsvsminus<l_rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
565 #if(CXSC_INDEX_CHECK) 566 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
570 {
return _vvminusassign(rv1,rv2); }
572 #if(CXSC_INDEX_CHECK) 573 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
577 {
return _vvsminusassign(rv,sl); }
579 #if(CXSC_INDEX_CHECK) 580 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
584 {
return _vsvminusassign(*
this,rv); }
586 #if(CXSC_INDEX_CHECK) 587 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
591 {
return _vsvsminusassign(*
this,sl2); }
593 INLINE
bool operator ==(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vveq(rv1,rv2); }
597 INLINE
bool operator !=(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vvneq(rv1,rv2); }
601 INLINE
bool operator <(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vvless(rv1,rv2); }
605 INLINE
bool operator <=(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vvleq(rv1,rv2); }
609 INLINE
bool operator >(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vvless(rv2,rv1); }
613 INLINE
bool operator >=(
const l_rvector &rv1,
const l_rvector &rv2)
throw() {
return _vvleq(rv2,rv1); }
623 #if(CXSC_INDEX_CHECK) 624 throw(OP_WITH_WRONG_DIM)
628 { _vvaccu(dp,rv2,rv1); }
630 #if(CXSC_INDEX_CHECK) 631 throw(OP_WITH_WRONG_DIM)
635 { _vvaccu(dp,rv1,rv2); }
637 #if(CXSC_INDEX_CHECK) 638 throw(OP_WITH_WRONG_DIM)
642 { _vsvaccu(dp,sl,rv); }
644 #if(CXSC_INDEX_CHECK) 645 throw(OP_WITH_WRONG_DIM)
649 { _vsvaccu(dp,sl,rv); }
651 #if(CXSC_INDEX_CHECK) 652 throw(OP_WITH_WRONG_DIM)
656 { _vsvaccu(dp,sl,rv); }
657 INLINE
void accumulate(dotprecision &dp,
const rvector & rv1,
const l_rmatrix_subv &rv2)
658 #if(CXSC_INDEX_CHECK) 659 throw(OP_WITH_WRONG_DIM)
664 INLINE
void accumulate(dotprecision &dp,
const l_rvector & rv1,
const rmatrix_subv &rv2)
665 #if(CXSC_INDEX_CHECK) 666 throw(OP_WITH_WRONG_DIM)
672 #if(CXSC_INDEX_CHECK) 673 throw(OP_WITH_WRONG_DIM)
677 { _vsvaccu(dp,sl,rv); }
678 INLINE
void accumulate(dotprecision &dp,
const rmatrix_subv & rv1,
const l_rvector &rv2)
679 #if(CXSC_INDEX_CHECK) 680 throw(OP_WITH_WRONG_DIM)
685 INLINE
void accumulate(dotprecision &dp,
const l_rmatrix_subv & rv1,
const rvector &rv2)
686 #if(CXSC_INDEX_CHECK) 687 throw(OP_WITH_WRONG_DIM)
692 INLINE
void accumulate(dotprecision &dp,
const rmatrix_subv & rv1,
const l_rmatrix_subv &rv2)
693 #if(CXSC_INDEX_CHECK) 694 throw(OP_WITH_WRONG_DIM)
699 INLINE
void accumulate(dotprecision &dp,
const l_rmatrix_subv & rv1,
const rmatrix_subv &rv2)
700 #if(CXSC_INDEX_CHECK) 701 throw(OP_WITH_WRONG_DIM)
707 #if(CXSC_INDEX_CHECK) 708 throw(OP_WITH_WRONG_DIM)
712 { _vsvsaccu(dp,sl2,sl1); }
714 #if(CXSC_INDEX_CHECK) 715 throw(OP_WITH_WRONG_DIM)
719 { _vsvsaccu(dp,sl1,sl2); }
722 #if(CXSC_INDEX_CHECK) 723 throw(OP_WITH_WRONG_DIM)
727 { _vvaccu(dp,rv2,rv1); }
729 #if(CXSC_INDEX_CHECK) 730 throw(OP_WITH_WRONG_DIM)
734 { _vvaccu(dp,rv1,rv2); }
736 #if(CXSC_INDEX_CHECK) 737 throw(OP_WITH_WRONG_DIM)
741 { _vsvaccu(dp,sl,rv); }
743 #if(CXSC_INDEX_CHECK) 744 throw(OP_WITH_WRONG_DIM)
748 { _vsvaccu(dp,sl,rv); }
750 #if(CXSC_INDEX_CHECK) 751 throw(OP_WITH_WRONG_DIM)
755 { _vsvaccu(dp,sl,rv); }
756 INLINE
void accumulate(idotprecision &dp,
const rvector & rv1,
const l_rmatrix_subv &rv2)
757 #if(CXSC_INDEX_CHECK) 758 throw(OP_WITH_WRONG_DIM)
763 INLINE
void accumulate(idotprecision &dp,
const l_rvector & rv1,
const rmatrix_subv &rv2)
764 #if(CXSC_INDEX_CHECK) 765 throw(OP_WITH_WRONG_DIM)
771 #if(CXSC_INDEX_CHECK) 772 throw(OP_WITH_WRONG_DIM)
776 { _vsvaccu(dp,sl,rv); }
777 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_rvector &rv2)
778 #if(CXSC_INDEX_CHECK) 779 throw(OP_WITH_WRONG_DIM)
784 INLINE
void accumulate(idotprecision &dp,
const l_rmatrix_subv & rv1,
const rvector &rv2)
785 #if(CXSC_INDEX_CHECK) 786 throw(OP_WITH_WRONG_DIM)
792 #if(CXSC_INDEX_CHECK) 793 throw(OP_WITH_WRONG_DIM)
797 { _vsvsaccu(dp,sl2,sl1); }
799 #if(CXSC_INDEX_CHECK) 800 throw(OP_WITH_WRONG_DIM)
804 { _vsvsaccu(dp,sl1,sl2); }
807 #if(CXSC_INDEX_CHECK) 808 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
812 {
return _vvlmult<rvector,l_rvector,l_real>(rv1,rv2); }
814 #if(CXSC_INDEX_CHECK) 815 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
819 {
return _vsvlmult<rvector_slice,l_rvector,l_real>(sl,rv); }
821 #if(CXSC_INDEX_CHECK) 822 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
826 {
return _vsvlmult<l_rvector_slice,rvector,l_real>(sl,rv); }
828 #if(CXSC_INDEX_CHECK) 829 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
833 {
return _vsvslmult<rvector_slice,l_rvector_slice,l_real>(sl1,sl2); }
836 #if(CXSC_INDEX_CHECK) 837 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
841 {
return _vvlmult<rvector,l_rvector,l_real>(rv2,rv1); }
843 #if(CXSC_INDEX_CHECK) 844 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
848 {
return _vsvlmult<l_rvector_slice,rvector,l_real>(sl,rv); }
850 #if(CXSC_INDEX_CHECK) 851 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
855 {
return _vsvlmult<rvector_slice,l_rvector,l_real>(sl,rv); }
857 #if(CXSC_INDEX_CHECK) 858 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
862 {
return _vsvslmult<rvector_slice,l_rvector_slice,l_real>(sl2,sl1); }
865 #if(CXSC_INDEX_CHECK) 866 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
870 {
return _vvplus<rvector,l_rvector,l_rvector>(rv1,rv2); }
872 #if(CXSC_INDEX_CHECK) 873 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
877 {
return _vvsplus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
879 #if(CXSC_INDEX_CHECK) 880 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
884 {
return _vvsplus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
886 #if(CXSC_INDEX_CHECK) 887 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
891 {
return _vsvsplus<rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
894 #if(CXSC_INDEX_CHECK) 895 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
899 {
return _vvplus<rvector,l_rvector,l_rvector>(rv2,rv1); }
901 #if(CXSC_INDEX_CHECK) 902 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
906 {
return _vvsplus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
908 #if(CXSC_INDEX_CHECK) 909 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
913 {
return _vvsplus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
915 #if(CXSC_INDEX_CHECK) 916 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
920 {
return _vsvsplus<rvector_slice,l_rvector_slice,l_rvector>(sl2,sl1); }
923 #if(CXSC_INDEX_CHECK) 924 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
928 {
return _vvplusassign(rv1,rv2); }
930 #if(CXSC_INDEX_CHECK) 931 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
935 {
return _vvsplusassign(rv,sl); }
937 #if(CXSC_INDEX_CHECK) 938 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
942 {
return _vsvplusassign(*
this,rv); }
944 #if(CXSC_INDEX_CHECK) 945 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
949 {
return _vsvsplusassign(*
this,sl2); }
952 #if(CXSC_INDEX_CHECK) 953 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
957 {
return _vvminus<rvector,l_rvector,l_rvector>(rv1,rv2); }
959 #if(CXSC_INDEX_CHECK) 960 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
964 {
return _vvsminus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
966 #if(CXSC_INDEX_CHECK) 967 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
971 {
return _vsvminus<rvector_slice,l_rvector,l_rvector>(sl,rv); }
973 #if(CXSC_INDEX_CHECK) 974 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
978 {
return _vsvsminus<rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
981 #if(CXSC_INDEX_CHECK) 982 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
986 {
return _vvminus<l_rvector,rvector,l_rvector>(rv1,rv2); }
988 #if(CXSC_INDEX_CHECK) 989 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
993 {
return _vvsminus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
995 #if(CXSC_INDEX_CHECK) 996 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1000 {
return _vsvminus<l_rvector_slice,rvector,l_rvector>(sl,rv); }
1002 #if(CXSC_INDEX_CHECK) 1003 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1007 {
return _vsvsminus<l_rvector_slice,rvector_slice,l_rvector>(sl1,sl2); }
1010 #if(CXSC_INDEX_CHECK) 1011 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1015 {
return _vvminusassign(rv1,rv2); }
1017 #if(CXSC_INDEX_CHECK) 1018 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1022 {
return _vvsminusassign(rv,sl); }
1024 #if(CXSC_INDEX_CHECK) 1025 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1029 {
return _vsvminusassign(*
this,rv); }
1031 #if(CXSC_INDEX_CHECK) 1032 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
1036 {
return _vsvsminusassign(*
this,sl2); }
l_rvector_slice & operator()()
Operator for accessing the whole vector.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
The Data Type idotprecision.
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.
The Multiple-Precision Data Type l_real.
The Data Type dotprecision.
l_real & operator [](const int &i) const
Operator for accessing the single elements of the vector.
The namespace cxsc, providing all functionality of the class library C-XSC.
l_real & operator [](const int &i) const
Operator for accessing the single elements of the vector.
l_rvector_slice & operator *=(const l_real &r)
Implementation of multiplication and allocation operation.
cimatrix & operator *=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
The Data Type rvector_slice.
l_rvector_slice & operator+=(const l_rvector &rv)
Implementation of addition and allocation operation.
civector operator *(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
l_rvector & operator()()
Operator for accessing the whole vector.
l_rvector_slice & operator/=(const l_real &r)
Implementation of division and allocation operation.
void Resize(cimatrix &A)
Resizes the matrix.
l_real(void)
Constructor of class l_real.
l_rvector_slice & operator -=(const l_rvector &rv)
Implementation of subtraction and allocation operation.
l_rvector()
Constructor of class l_rvector.
The Multiple-Precision Data Type l_rvector.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
l_rvector_slice & operator=(const l_rvector_slice &sl)
Implementation of standard assigning operator.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
The Multiple-Precision Data Type l_rvector_slice.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
l_rvector & operator=(const l_rvector &rv)
Implementation of standard assigning operator.