00001
00002
00003
00006
00007
00008
00009 #ifndef NEWMAT_LIB
00010 #define NEWMAT_LIB 0
00011
00012 #include "include.h"
00013
00014 #include "myexcept.h"
00015
00016
00017 #ifdef use_namespace
00018 namespace NEWMAT { using namespace RBD_COMMON; }
00019 namespace RBD_LIBRARIES { using namespace NEWMAT; }
00020 namespace NEWMAT {
00021 #endif
00022
00023
00024
00025 #ifdef NO_LONG_NAMES
00026 #define UpperTriangularMatrix UTMatrix
00027 #define LowerTriangularMatrix LTMatrix
00028 #define SymmetricMatrix SMatrix
00029 #define DiagonalMatrix DMatrix
00030 #define BandMatrix BMatrix
00031 #define UpperBandMatrix UBMatrix
00032 #define LowerBandMatrix LBMatrix
00033 #define SymmetricBandMatrix SBMatrix
00034 #define BandLUMatrix BLUMatrix
00035 #endif
00036
00037
00038
00039 class GeneralMatrix;
00040 class BaseMatrix;
00041 class MatrixInput;
00042
00043 void MatrixErrorNoSpace(const void*);
00044
00047 class LogAndSign
00048 {
00049 Real log_val;
00050 int sign_val;
00051 public:
00052 LogAndSign() { log_val=0.0; sign_val=1; }
00053 LogAndSign(Real);
00054 void operator*=(Real);
00055 void pow_eq(int k);
00056 void PowEq(int k) { pow_eq(k); }
00057 void ChangeSign() { sign_val = -sign_val; }
00058 void change_sign() { sign_val = -sign_val; }
00059 Real LogValue() const { return log_val; }
00060 Real log_value() const { return log_val; }
00061 int Sign() const { return sign_val; }
00062 int sign() const { return sign_val; }
00063 Real value() const;
00064 Real Value() const { return value(); }
00065 FREE_CHECK(LogAndSign)
00066 };
00067
00068
00069
00070
00071
00072
00073
00074
00075 #ifdef DO_REPORT
00076
00077 class ExeCounter
00078 {
00079 int line;
00080 int fileid;
00081 long nexe;
00082 static int nreports;
00083 public:
00084 ExeCounter(int,int);
00085 void operator++() { nexe++; }
00086 ~ExeCounter();
00087 };
00088
00089 #endif
00090
00091
00092
00093
00097
00098 class MatrixType
00099 {
00100 public:
00101 enum Attribute { Valid = 1,
00102 Diagonal = 2,
00103 Symmetric = 4,
00104 Band = 8,
00105 Lower = 16,
00106 Upper = 32,
00107 Square = 64,
00108 Skew = 128,
00109 LUDeco = 256,
00110 Ones = 512 };
00111
00112 enum { US = 0,
00113 UT = Valid + Upper + Square,
00114 LT = Valid + Lower + Square,
00115 Rt = Valid,
00116 Sq = Valid + Square,
00117 Sm = Valid + Symmetric + Square,
00118 Sk = Valid + Skew + Square,
00119 Dg = Valid + Diagonal + Band + Lower + Upper + Symmetric
00120 + Square,
00121 Id = Valid + Diagonal + Band + Lower + Upper + Symmetric
00122 + Square + Ones,
00123 RV = Valid,
00124 CV = Valid,
00125 BM = Valid + Band + Square,
00126 UB = Valid + Band + Upper + Square,
00127 LB = Valid + Band + Lower + Square,
00128 SB = Valid + Band + Symmetric + Square,
00129 KB = Valid + Band + Skew + Square,
00130 Ct = Valid + LUDeco + Square,
00131 BC = Valid + Band + LUDeco + Square,
00132 Mask = ~Square
00133 };
00134
00135
00136 static int nTypes() { return 13; }
00137
00138 public:
00139 int attribute;
00140 bool DataLossOK;
00141
00142 public:
00143 MatrixType () : DataLossOK(false) {}
00144 MatrixType (int i) : attribute(i), DataLossOK(false) {}
00145 MatrixType (int i, bool dlok) : attribute(i), DataLossOK(dlok) {}
00146 MatrixType (const MatrixType& mt)
00147 : attribute(mt.attribute), DataLossOK(mt.DataLossOK) {}
00148 void operator=(const MatrixType& mt)
00149 { attribute = mt.attribute; DataLossOK = mt.DataLossOK; }
00150 void SetDataLossOK() { DataLossOK = true; }
00151 int operator+() const { return attribute; }
00152 MatrixType operator+(MatrixType mt) const
00153 { return MatrixType(attribute & mt.attribute); }
00154 MatrixType operator*(const MatrixType&) const;
00155 MatrixType SP(const MatrixType&) const;
00156 MatrixType KP(const MatrixType&) const;
00157 MatrixType operator|(const MatrixType& mt) const
00158 { return MatrixType(attribute & mt.attribute & Valid); }
00159 MatrixType operator&(const MatrixType& mt) const
00160 { return MatrixType(attribute & mt.attribute & Valid); }
00161 bool operator>=(MatrixType mt) const
00162 { return ( attribute & ~mt.attribute & Mask ) == 0; }
00163 bool operator<(MatrixType mt) const
00164 { return ( attribute & ~mt.attribute & Mask ) != 0; }
00165 bool operator==(MatrixType t) const
00166 { return (attribute == t.attribute); }
00167 bool operator!=(MatrixType t) const
00168 { return (attribute != t.attribute); }
00169 bool operator!() const { return (attribute & Valid) == 0; }
00170 MatrixType i() const;
00171 MatrixType t() const;
00172 MatrixType AddEqualEl() const
00173 { return MatrixType(attribute & (Valid + Symmetric + Square)); }
00174 MatrixType MultRHS() const;
00175 MatrixType sub() const
00176 { return MatrixType(attribute & Valid); }
00177 MatrixType ssub() const
00178 { return MatrixType(attribute); }
00179 GeneralMatrix* New() const;
00180 GeneralMatrix* New(int,int,BaseMatrix*) const;
00182 const char* value() const;
00183 const char* Value() const { return value(); }
00184 friend bool Rectangular(MatrixType a, MatrixType b, MatrixType c);
00185 friend bool Compare(const MatrixType&, MatrixType&);
00187 bool is_band() const { return (attribute & Band) != 0; }
00188 bool is_diagonal() const { return (attribute & Diagonal) != 0; }
00189 bool is_symmetric() const { return (attribute & Symmetric) != 0; }
00190 bool CannotConvert() const { return (attribute & LUDeco) != 0; }
00191
00192 FREE_CHECK(MatrixType)
00193 };
00194
00195
00196
00197
00202 class MatrixBandWidth
00203 {
00204 public:
00205 int lower_val;
00206 int upper_val;
00207 MatrixBandWidth(const int l, const int u) : lower_val(l), upper_val(u) {}
00208 MatrixBandWidth(const int i) : lower_val(i), upper_val(i) {}
00209 MatrixBandWidth operator+(const MatrixBandWidth&) const;
00210 MatrixBandWidth operator*(const MatrixBandWidth&) const;
00211 MatrixBandWidth minimum(const MatrixBandWidth&) const;
00212 MatrixBandWidth t() const { return MatrixBandWidth(upper_val,lower_val); }
00213 bool operator==(const MatrixBandWidth& bw) const
00214 { return (lower_val == bw.lower_val) && (upper_val == bw.upper_val); }
00215 bool operator!=(const MatrixBandWidth& bw) const { return !operator==(bw); }
00216 int Upper() const { return upper_val; }
00217 int upper() const { return upper_val; }
00218 int Lower() const { return lower_val; }
00219 int lower() const { return lower_val; }
00220 FREE_CHECK(MatrixBandWidth)
00221 };
00222
00223
00224
00225
00229
00230 class ArrayLengthSpecifier
00231 {
00232 int v;
00233 public:
00234 int Value() const { return v; }
00235 int value() const { return v; }
00236 ArrayLengthSpecifier(int l) : v(l) {}
00237 };
00238
00239
00240
00241
00242 class MatrixRowCol;
00243 class MatrixRow;
00244 class MatrixCol;
00245 class MatrixColX;
00246
00247 class GeneralMatrix;
00248 class AddedMatrix;
00249 class MultipliedMatrix;
00250 class SubtractedMatrix;
00251 class SPMatrix;
00252 class KPMatrix;
00253 class ConcatenatedMatrix;
00254 class StackedMatrix;
00255 class SolvedMatrix;
00256 class ShiftedMatrix;
00257 class NegShiftedMatrix;
00258 class ScaledMatrix;
00259 class TransposedMatrix;
00260 class ReversedMatrix;
00261 class NegatedMatrix;
00262 class InvertedMatrix;
00263 class RowedMatrix;
00264 class ColedMatrix;
00265 class DiagedMatrix;
00266 class MatedMatrix;
00267 class GetSubMatrix;
00268 class ReturnMatrix;
00269 class Matrix;
00270 class SquareMatrix;
00271 class nricMatrix;
00272 class RowVector;
00273 class ColumnVector;
00274 class SymmetricMatrix;
00275 class UpperTriangularMatrix;
00276 class LowerTriangularMatrix;
00277 class DiagonalMatrix;
00278 class CroutMatrix;
00279 class BandMatrix;
00280 class LowerBandMatrix;
00281 class UpperBandMatrix;
00282 class SymmetricBandMatrix;
00283 class LinearEquationSolver;
00284 class GenericMatrix;
00285
00286
00287 #define MatrixTypeUnSp 0
00288
00289
00290
00292 class BaseMatrix : public Janitor
00293 {
00294 protected:
00295 virtual int search(const BaseMatrix*) const = 0;
00296
00297 public:
00298 virtual GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp) = 0;
00299
00300
00301
00302
00303 AddedMatrix operator+(const BaseMatrix&) const;
00304 MultipliedMatrix operator*(const BaseMatrix&) const;
00305 SubtractedMatrix operator-(const BaseMatrix&) const;
00306 ConcatenatedMatrix operator|(const BaseMatrix&) const;
00307 StackedMatrix operator&(const BaseMatrix&) const;
00308 ShiftedMatrix operator+(Real) const;
00309 ScaledMatrix operator*(Real) const;
00310 ScaledMatrix operator/(Real) const;
00311 ShiftedMatrix operator-(Real) const;
00312 TransposedMatrix t() const;
00313
00314 NegatedMatrix operator-() const;
00315 ReversedMatrix reverse() const;
00316 ReversedMatrix Reverse() const;
00317 InvertedMatrix i() const;
00318
00319 RowedMatrix as_row() const;
00320 RowedMatrix AsRow() const;
00321 ColedMatrix as_column() const;
00322 ColedMatrix AsColumn() const;
00323 DiagedMatrix as_diagonal() const;
00324 DiagedMatrix AsDiagonal() const;
00325 MatedMatrix as_matrix(int,int) const;
00326 MatedMatrix AsMatrix(int m, int n) const;
00327 GetSubMatrix submatrix(int,int,int,int) const;
00328 GetSubMatrix SubMatrix(int fr, int lr, int fc, int lc) const;
00329 GetSubMatrix sym_submatrix(int,int) const;
00330 GetSubMatrix SymSubMatrix(int f, int l) const;
00331 GetSubMatrix row(int) const;
00332 GetSubMatrix rows(int,int) const;
00333 GetSubMatrix column(int) const;
00334 GetSubMatrix columns(int,int) const;
00335 GetSubMatrix Row(int f) const;
00336 GetSubMatrix Rows(int f, int l) const;
00337 GetSubMatrix Column(int f) const;
00338 GetSubMatrix Columns(int f, int l) const;
00339 Real as_scalar() const;
00340 Real AsScalar() const;
00341 virtual LogAndSign log_determinant() const;
00342 LogAndSign LogDeterminant() const { return log_determinant(); }
00343 Real determinant() const;
00344 Real Determinant() const { return determinant(); }
00345 virtual Real sum_square() const;
00346 Real SumSquare() const { return sum_square(); }
00347 Real norm_Frobenius() const;
00348 Real norm_frobenius() const { return norm_Frobenius(); }
00349 Real NormFrobenius() const { return norm_Frobenius(); }
00350 virtual Real sum_absolute_value() const;
00351 Real SumAbsoluteValue() const { return sum_absolute_value(); }
00352 virtual Real sum() const;
00353 virtual Real Sum() const { return sum(); }
00354 virtual Real maximum_absolute_value() const;
00355 Real MaximumAbsoluteValue() const { return maximum_absolute_value(); }
00356 virtual Real maximum_absolute_value1(int& i) const;
00357 Real MaximumAbsoluteValue1(int& i) const
00358 { return maximum_absolute_value1(i); }
00359 virtual Real maximum_absolute_value2(int& i, int& j) const;
00360 Real MaximumAbsoluteValue2(int& i, int& j) const
00361 { return maximum_absolute_value2(i,j); }
00362 virtual Real minimum_absolute_value() const;
00363 Real MinimumAbsoluteValue() const { return minimum_absolute_value(); }
00364 virtual Real minimum_absolute_value1(int& i) const;
00365 Real MinimumAbsoluteValue1(int& i) const
00366 { return minimum_absolute_value1(i); }
00367 virtual Real minimum_absolute_value2(int& i, int& j) const;
00368 Real MinimumAbsoluteValue2(int& i, int& j) const
00369 { return minimum_absolute_value2(i,j); }
00370 virtual Real maximum() const;
00371 Real Maximum() const { return maximum(); }
00372 virtual Real maximum1(int& i) const;
00373 Real Maximum1(int& i) const { return maximum1(i); }
00374 virtual Real maximum2(int& i, int& j) const;
00375 Real Maximum2(int& i, int& j) const { return maximum2(i,j); }
00376 virtual Real minimum() const;
00377 Real Minimum() const { return minimum(); }
00378 virtual Real minimum1(int& i) const;
00379 Real Minimum1(int& i) const { return minimum1(i); }
00380 virtual Real minimum2(int& i, int& j) const;
00381 Real Minimum2(int& i, int& j) const { return minimum2(i,j); }
00382 virtual Real trace() const;
00383 Real Trace() const { return trace(); }
00384 Real norm1() const;
00385 Real Norm1() const { return norm1(); }
00386 Real norm_infinity() const;
00387 Real NormInfinity() const { return norm_infinity(); }
00388 virtual MatrixBandWidth bandwidth() const;
00389 virtual MatrixBandWidth BandWidth() const { return bandwidth(); }
00390 void IEQND() const;
00391 ReturnMatrix sum_square_columns() const;
00392 ReturnMatrix sum_square_rows() const;
00393 ReturnMatrix sum_columns() const;
00394 ReturnMatrix sum_rows() const;
00395 virtual void cleanup() {}
00396 void CleanUp() { cleanup(); }
00397
00398
00399
00400
00401
00402 friend class GeneralMatrix;
00403 friend class Matrix;
00404 friend class SquareMatrix;
00405 friend class nricMatrix;
00406 friend class RowVector;
00407 friend class ColumnVector;
00408 friend class SymmetricMatrix;
00409 friend class UpperTriangularMatrix;
00410 friend class LowerTriangularMatrix;
00411 friend class DiagonalMatrix;
00412 friend class CroutMatrix;
00413 friend class BandMatrix;
00414 friend class LowerBandMatrix;
00415 friend class UpperBandMatrix;
00416 friend class SymmetricBandMatrix;
00417 friend class AddedMatrix;
00418 friend class MultipliedMatrix;
00419 friend class SubtractedMatrix;
00420 friend class SPMatrix;
00421 friend class KPMatrix;
00422 friend class ConcatenatedMatrix;
00423 friend class StackedMatrix;
00424 friend class SolvedMatrix;
00425 friend class ShiftedMatrix;
00426 friend class NegShiftedMatrix;
00427 friend class ScaledMatrix;
00428 friend class TransposedMatrix;
00429 friend class ReversedMatrix;
00430 friend class NegatedMatrix;
00431 friend class InvertedMatrix;
00432 friend class RowedMatrix;
00433 friend class ColedMatrix;
00434 friend class DiagedMatrix;
00435 friend class MatedMatrix;
00436 friend class GetSubMatrix;
00437 friend class ReturnMatrix;
00438 friend class LinearEquationSolver;
00439 friend class GenericMatrix;
00440 NEW_DELETE(BaseMatrix)
00441 };
00442
00443
00444
00445
00447 class GeneralMatrix : public BaseMatrix
00448 {
00449 virtual GeneralMatrix* Image() const;
00450 protected:
00451 int tag_val;
00452 int nrows_val, ncols_val;
00453 int storage;
00454 Real* store;
00455 GeneralMatrix();
00456 GeneralMatrix(ArrayLengthSpecifier);
00457 void Add(GeneralMatrix*, Real);
00458 void Add(Real);
00459 void NegAdd(GeneralMatrix*, Real);
00460 void NegAdd(Real);
00461 void Multiply(GeneralMatrix*, Real);
00462 void Multiply(Real);
00463 void Negate(GeneralMatrix*);
00464 void Negate();
00465 void ReverseElements();
00466 void ReverseElements(GeneralMatrix*);
00467 void operator=(Real);
00468 Real* GetStore();
00469 GeneralMatrix* BorrowStore(GeneralMatrix*, MatrixType);
00470
00471 void GetMatrix(const GeneralMatrix*);
00472 void Eq(const BaseMatrix&, MatrixType);
00473 void Eq(const GeneralMatrix&);
00474 void Eq(const BaseMatrix&, MatrixType, bool);
00475 void Eq2(const BaseMatrix&, MatrixType);
00476 int search(const BaseMatrix*) const;
00477 virtual GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
00478 void CheckConversion(const BaseMatrix&);
00479 void resize(int, int, int);
00480 virtual short SimpleAddOK(const GeneralMatrix*) { return 0; }
00481
00482 virtual void MiniCleanUp()
00483 { store = 0; storage = 0; nrows_val = 0; ncols_val = 0; tag_val = -1;}
00484
00485 void PlusEqual(const GeneralMatrix& gm);
00486 void MinusEqual(const GeneralMatrix& gm);
00487 void PlusEqual(Real f);
00488 void MinusEqual(Real f);
00489 void swap(GeneralMatrix& gm);
00490 public:
00491 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
00492 virtual MatrixType type() const = 0;
00493 MatrixType Type() const { return type(); }
00494 int Nrows() const { return nrows_val; }
00495 int Ncols() const { return ncols_val; }
00496 int Storage() const { return storage; }
00497 Real* Store() const { return store; }
00498
00499 int nrows() const { return nrows_val; }
00500 int ncols() const { return ncols_val; }
00501 int size() const { return storage; }
00502 Real* data() { return store; }
00503 const Real* data() const { return store; }
00504 const Real* const_data() const { return store; }
00505 virtual ~GeneralMatrix();
00506 void tDelete();
00507 bool reuse();
00508 void protect() { tag_val=-1; }
00509 void Protect() { tag_val=-1; }
00510 int tag() const { return tag_val; }
00511 int Tag() const { return tag_val; }
00512 bool is_zero() const;
00513 bool IsZero() const { return is_zero(); }
00514 void Release() { tag_val=1; }
00515 void Release(int t) { tag_val=t; }
00516 void ReleaseAndDelete() { tag_val=0; }
00517 void release() { tag_val=1; }
00518 void release(int t) { tag_val=t; }
00519 void release_and_delete() { tag_val=0; }
00520 void operator<<(const double*);
00521 void operator<<(const float*);
00522 void operator<<(const int*);
00523 void operator<<(const BaseMatrix& X)
00524 { Eq(X,this->type(),true); }
00525 void inject(const GeneralMatrix&);
00526 void Inject(const GeneralMatrix& GM) { inject(GM); }
00527 void operator+=(const BaseMatrix&);
00528 void operator-=(const BaseMatrix&);
00529 void operator*=(const BaseMatrix&);
00530 void operator|=(const BaseMatrix&);
00531 void operator&=(const BaseMatrix&);
00532 void operator+=(Real);
00533 void operator-=(Real r) { operator+=(-r); }
00534 void operator*=(Real);
00535 void operator/=(Real r) { operator*=(1.0/r); }
00536 virtual GeneralMatrix* MakeSolver();
00537 virtual void Solver(MatrixColX&, const MatrixColX&) {}
00538 virtual void GetRow(MatrixRowCol&) = 0;
00539 virtual void RestoreRow(MatrixRowCol&) {}
00540 virtual void NextRow(MatrixRowCol&);
00541 virtual void GetCol(MatrixRowCol&) = 0;
00542 virtual void GetCol(MatrixColX&) = 0;
00543 virtual void RestoreCol(MatrixRowCol&) {}
00544 virtual void RestoreCol(MatrixColX&) {}
00545 virtual void NextCol(MatrixRowCol&);
00546 virtual void NextCol(MatrixColX&);
00547 Real sum_square() const;
00548 Real sum_absolute_value() const;
00549 Real sum() const;
00550 Real maximum_absolute_value1(int& i) const;
00551 Real minimum_absolute_value1(int& i) const;
00552 Real maximum1(int& i) const;
00553 Real minimum1(int& i) const;
00554 Real maximum_absolute_value() const;
00555 Real maximum_absolute_value2(int& i, int& j) const;
00556 Real minimum_absolute_value() const;
00557 Real minimum_absolute_value2(int& i, int& j) const;
00558 Real maximum() const;
00559 Real maximum2(int& i, int& j) const;
00560 Real minimum() const;
00561 Real minimum2(int& i, int& j) const;
00562 LogAndSign log_determinant() const;
00563 virtual bool IsEqual(const GeneralMatrix&) const;
00564
00565 void CheckStore() const;
00566 virtual void SetParameters(const GeneralMatrix*) {}
00567
00568 operator ReturnMatrix() const;
00569 ReturnMatrix for_return() const;
00570 ReturnMatrix ForReturn() const;
00571
00572
00573
00574 virtual void resize(const GeneralMatrix& A);
00575 virtual void ReSize(const GeneralMatrix& A) { resize(A); }
00576 MatrixInput operator<<(double);
00577 MatrixInput operator<<(float);
00578 MatrixInput operator<<(int f);
00579
00580 void cleanup();
00581
00582 friend class Matrix;
00583 friend class SquareMatrix;
00584 friend class nricMatrix;
00585 friend class SymmetricMatrix;
00586 friend class UpperTriangularMatrix;
00587 friend class LowerTriangularMatrix;
00588 friend class DiagonalMatrix;
00589 friend class CroutMatrix;
00590 friend class RowVector;
00591 friend class ColumnVector;
00592 friend class BandMatrix;
00593 friend class LowerBandMatrix;
00594 friend class UpperBandMatrix;
00595 friend class SymmetricBandMatrix;
00596 friend class BaseMatrix;
00597 friend class AddedMatrix;
00598 friend class MultipliedMatrix;
00599 friend class SubtractedMatrix;
00600 friend class SPMatrix;
00601 friend class KPMatrix;
00602 friend class ConcatenatedMatrix;
00603 friend class StackedMatrix;
00604 friend class SolvedMatrix;
00605 friend class ShiftedMatrix;
00606 friend class NegShiftedMatrix;
00607 friend class ScaledMatrix;
00608 friend class TransposedMatrix;
00609 friend class ReversedMatrix;
00610 friend class NegatedMatrix;
00611 friend class InvertedMatrix;
00612 friend class RowedMatrix;
00613 friend class ColedMatrix;
00614 friend class DiagedMatrix;
00615 friend class MatedMatrix;
00616 friend class GetSubMatrix;
00617 friend class ReturnMatrix;
00618 friend class LinearEquationSolver;
00619 friend class GenericMatrix;
00620 NEW_DELETE(GeneralMatrix)
00621 };
00622
00623
00625 class Matrix : public GeneralMatrix
00626 {
00627 GeneralMatrix* Image() const;
00628 public:
00629 Matrix() {}
00630 ~Matrix() {}
00631 Matrix(int, int);
00632 Matrix(const BaseMatrix&);
00633 void operator=(const BaseMatrix&);
00634 void operator=(Real f) { GeneralMatrix::operator=(f); }
00635 void operator=(const Matrix& m) { Eq(m); }
00636 MatrixType type() const;
00637 Real& operator()(int, int);
00638 Real& element(int, int);
00639 Real operator()(int, int) const;
00640 Real element(int, int) const;
00641 #ifdef SETUP_C_SUBSCRIPTS
00642 Real* operator[](int m) { return store+m*ncols_val; }
00643 const Real* operator[](int m) const { return store+m*ncols_val; }
00644
00645 Matrix(Real, int, int);
00646 Matrix(const Real*, int, int);
00647 #endif
00648 Matrix(const Matrix& gm) : GeneralMatrix() { GetMatrix(&gm); }
00649 GeneralMatrix* MakeSolver();
00650 Real trace() const;
00651 void GetRow(MatrixRowCol&);
00652 void GetCol(MatrixRowCol&);
00653 void GetCol(MatrixColX&);
00654 void RestoreCol(MatrixRowCol&);
00655 void RestoreCol(MatrixColX&);
00656 void NextRow(MatrixRowCol&);
00657 void NextCol(MatrixRowCol&);
00658 void NextCol(MatrixColX&);
00659 virtual void resize(int,int);
00660
00661 virtual void resize_keep(int,int);
00662 virtual void ReSize(int m, int n) { resize(m, n); }
00663 void resize(const GeneralMatrix& A);
00664 void ReSize(const GeneralMatrix& A) { resize(A); }
00665 Real maximum_absolute_value2(int& i, int& j) const;
00666 Real minimum_absolute_value2(int& i, int& j) const;
00667 Real maximum2(int& i, int& j) const;
00668 Real minimum2(int& i, int& j) const;
00669 void operator+=(const Matrix& M) { PlusEqual(M); }
00670 void operator-=(const Matrix& M) { MinusEqual(M); }
00671 void operator+=(Real f) { GeneralMatrix::Add(f); }
00672 void operator-=(Real f) { GeneralMatrix::Add(-f); }
00673 void swap(Matrix& gm) { GeneralMatrix::swap((GeneralMatrix&)gm); }
00674 friend Real dotproduct(const Matrix& A, const Matrix& B);
00675 NEW_DELETE(Matrix)
00676 };
00677
00679 class SquareMatrix : public Matrix
00680 {
00681 GeneralMatrix* Image() const;
00682 public:
00683 SquareMatrix() {}
00684 ~SquareMatrix() {}
00685 SquareMatrix(ArrayLengthSpecifier);
00686 SquareMatrix(const BaseMatrix&);
00687 void operator=(const BaseMatrix&);
00688 void operator=(Real f) { GeneralMatrix::operator=(f); }
00689 void operator=(const SquareMatrix& m) { Eq(m); }
00690 void operator=(const Matrix& m);
00691 MatrixType type() const;
00692 SquareMatrix(const SquareMatrix& gm) : Matrix() { GetMatrix(&gm); }
00693 SquareMatrix(const Matrix& gm);
00694 void resize(int);
00695 void ReSize(int m) { resize(m); }
00696 void resize_keep(int);
00697 void resize_keep(int,int);
00698 void resize(int,int);
00699 void ReSize(int m, int n) { resize(m, n); }
00700 void resize(const GeneralMatrix& A);
00701 void ReSize(const GeneralMatrix& A) { resize(A); }
00702 void operator+=(const Matrix& M) { PlusEqual(M); }
00703 void operator-=(const Matrix& M) { MinusEqual(M); }
00704 void operator+=(Real f) { GeneralMatrix::Add(f); }
00705 void operator-=(Real f) { GeneralMatrix::Add(-f); }
00706 void swap(SquareMatrix& gm) { GeneralMatrix::swap((GeneralMatrix&)gm); }
00707 NEW_DELETE(SquareMatrix)
00708 };
00709
00711 class nricMatrix : public Matrix
00712 {
00713 GeneralMatrix* Image() const;
00714 Real** row_pointer;
00715 void MakeRowPointer();
00716 void DeleteRowPointer();
00717 public:
00718 nricMatrix() {}
00719 nricMatrix(int m, int n)
00720 : Matrix(m,n) { MakeRowPointer(); }
00721 nricMatrix(const BaseMatrix& bm)
00722 : Matrix(bm) { MakeRowPointer(); }
00723 void operator=(const BaseMatrix& bm)
00724 { DeleteRowPointer(); Matrix::operator=(bm); MakeRowPointer(); }
00725 void operator=(Real f) { GeneralMatrix::operator=(f); }
00726 void operator=(const nricMatrix& m)
00727 { DeleteRowPointer(); Eq(m); MakeRowPointer(); }
00728 void operator<<(const BaseMatrix& X)
00729 { DeleteRowPointer(); Eq(X,this->type(),true); MakeRowPointer(); }
00730 nricMatrix(const nricMatrix& gm) : Matrix()
00731 { GetMatrix(&gm); MakeRowPointer(); }
00732 void resize(int m, int n)
00733 { DeleteRowPointer(); Matrix::resize(m,n); MakeRowPointer(); }
00734 void resize_keep(int m, int n)
00735 { DeleteRowPointer(); Matrix::resize_keep(m,n); MakeRowPointer(); }
00736 void ReSize(int m, int n)
00737 { DeleteRowPointer(); Matrix::resize(m,n); MakeRowPointer(); }
00738 void resize(const GeneralMatrix& A);
00739 void ReSize(const GeneralMatrix& A) { resize(A); }
00740 ~nricMatrix() { DeleteRowPointer(); }
00741 Real** nric() const { CheckStore(); return row_pointer-1; }
00742 void cleanup();
00743 void MiniCleanUp();
00744 void operator+=(const Matrix& M) { PlusEqual(M); }
00745 void operator-=(const Matrix& M) { MinusEqual(M); }
00746 void operator+=(Real f) { GeneralMatrix::Add(f); }
00747 void operator-=(Real f) { GeneralMatrix::Add(-f); }
00748 void swap(nricMatrix& gm);
00749 NEW_DELETE(nricMatrix)
00750 };
00751
00753 class SymmetricMatrix : public GeneralMatrix
00754 {
00755 GeneralMatrix* Image() const;
00756 public:
00757 SymmetricMatrix() {}
00758 ~SymmetricMatrix() {}
00759 SymmetricMatrix(ArrayLengthSpecifier);
00760 SymmetricMatrix(const BaseMatrix&);
00761 void operator=(const BaseMatrix&);
00762 void operator=(Real f) { GeneralMatrix::operator=(f); }
00763 void operator=(const SymmetricMatrix& m) { Eq(m); }
00764 Real& operator()(int, int);
00765 Real& element(int, int);
00766 Real operator()(int, int) const;
00767 Real element(int, int) const;
00768 #ifdef SETUP_C_SUBSCRIPTS
00769 Real* operator[](int m) { return store+(m*(m+1))/2; }
00770 const Real* operator[](int m) const { return store+(m*(m+1))/2; }
00771 #endif
00772 MatrixType type() const;
00773 SymmetricMatrix(const SymmetricMatrix& gm)
00774 : GeneralMatrix() { GetMatrix(&gm); }
00775 Real sum_square() const;
00776 Real sum_absolute_value() const;
00777 Real sum() const;
00778 Real trace() const;
00779 void GetRow(MatrixRowCol&);
00780 void GetCol(MatrixRowCol&);
00781 void GetCol(MatrixColX&);
00782 void RestoreCol(MatrixRowCol&) {}
00783 void RestoreCol(MatrixColX&);
00784 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
00785 void resize(int);
00786 void ReSize(int m) { resize(m); }
00787 void resize_keep(int);
00788 void resize(const GeneralMatrix& A);
00789 void ReSize(const GeneralMatrix& A) { resize(A); }
00790 void operator+=(const SymmetricMatrix& M) { PlusEqual(M); }
00791 void operator-=(const SymmetricMatrix& M) { MinusEqual(M); }
00792 void operator+=(Real f) { GeneralMatrix::Add(f); }
00793 void operator-=(Real f) { GeneralMatrix::Add(-f); }
00794 void swap(SymmetricMatrix& gm) { GeneralMatrix::swap((GeneralMatrix&)gm); }
00795 NEW_DELETE(SymmetricMatrix)
00796 };
00797
00799 class UpperTriangularMatrix : public GeneralMatrix
00800 {
00801 GeneralMatrix* Image() const;
00802 public:
00803 UpperTriangularMatrix() {}
00804 ~UpperTriangularMatrix() {}
00805 UpperTriangularMatrix(ArrayLengthSpecifier);
00806 void operator=(const BaseMatrix&);
00807 void operator=(const UpperTriangularMatrix& m) { Eq(m); }
00808 UpperTriangularMatrix(const BaseMatrix&);
00809 UpperTriangularMatrix(const UpperTriangularMatrix& gm)
00810 : GeneralMatrix() { GetMatrix(&gm); }
00811 void operator=(Real f) { GeneralMatrix::operator=(f); }
00812 Real& operator()(int, int);
00813 Real& element(int, int);
00814 Real operator()(int, int) const;
00815 Real element(int, int) const;
00816 #ifdef SETUP_C_SUBSCRIPTS
00817 Real* operator[](int m) { return store+m*ncols_val-(m*(m+1))/2; }
00818 const Real* operator[](int m) const
00819 { return store+m*ncols_val-(m*(m+1))/2; }
00820 #endif
00821 MatrixType type() const;
00822 GeneralMatrix* MakeSolver() { return this; }
00823 void Solver(MatrixColX&, const MatrixColX&);
00824 LogAndSign log_determinant() const;
00825 Real trace() const;
00826 void GetRow(MatrixRowCol&);
00827 void GetCol(MatrixRowCol&);
00828 void GetCol(MatrixColX&);
00829 void RestoreCol(MatrixRowCol&);
00830 void RestoreCol(MatrixColX& c) { RestoreCol((MatrixRowCol&)c); }
00831 void NextRow(MatrixRowCol&);
00832 void resize(int);
00833 void ReSize(int m) { resize(m); }
00834 void resize(const GeneralMatrix& A);
00835 void ReSize(const GeneralMatrix& A) { resize(A); }
00836 void resize_keep(int);
00837 MatrixBandWidth bandwidth() const;
00838 void operator+=(const UpperTriangularMatrix& M) { PlusEqual(M); }
00839 void operator-=(const UpperTriangularMatrix& M) { MinusEqual(M); }
00840 void operator+=(Real f) { GeneralMatrix::operator+=(f); }
00841 void operator-=(Real f) { GeneralMatrix::operator-=(f); }
00842 void swap(UpperTriangularMatrix& gm)
00843 { GeneralMatrix::swap((GeneralMatrix&)gm); }
00844 NEW_DELETE(UpperTriangularMatrix)
00845 };
00846
00848 class LowerTriangularMatrix : public GeneralMatrix
00849 {
00850 GeneralMatrix* Image() const;
00851 public:
00852 LowerTriangularMatrix() {}
00853 ~LowerTriangularMatrix() {}
00854 LowerTriangularMatrix(ArrayLengthSpecifier);
00855 LowerTriangularMatrix(const LowerTriangularMatrix& gm)
00856 : GeneralMatrix() { GetMatrix(&gm); }
00857 LowerTriangularMatrix(const BaseMatrix& M);
00858 void operator=(const BaseMatrix&);
00859 void operator=(Real f) { GeneralMatrix::operator=(f); }
00860 void operator=(const LowerTriangularMatrix& m) { Eq(m); }
00861 Real& operator()(int, int);
00862 Real& element(int, int);
00863 Real operator()(int, int) const;
00864 Real element(int, int) const;
00865 #ifdef SETUP_C_SUBSCRIPTS
00866 Real* operator[](int m) { return store+(m*(m+1))/2; }
00867 const Real* operator[](int m) const { return store+(m*(m+1))/2; }
00868 #endif
00869 MatrixType type() const;
00870 GeneralMatrix* MakeSolver() { return this; }
00871 void Solver(MatrixColX&, const MatrixColX&);
00872 LogAndSign log_determinant() const;
00873 Real trace() const;
00874 void GetRow(MatrixRowCol&);
00875 void GetCol(MatrixRowCol&);
00876 void GetCol(MatrixColX&);
00877 void RestoreCol(MatrixRowCol&);
00878 void RestoreCol(MatrixColX& c) { RestoreCol((MatrixRowCol&)c); }
00879 void NextRow(MatrixRowCol&);
00880 void resize(int);
00881 void ReSize(int m) { resize(m); }
00882 void resize_keep(int);
00883 void resize(const GeneralMatrix& A);
00884 void ReSize(const GeneralMatrix& A) { resize(A); }
00885 MatrixBandWidth bandwidth() const;
00886 void operator+=(const LowerTriangularMatrix& M) { PlusEqual(M); }
00887 void operator-=(const LowerTriangularMatrix& M) { MinusEqual(M); }
00888 void operator+=(Real f) { GeneralMatrix::operator+=(f); }
00889 void operator-=(Real f) { GeneralMatrix::operator-=(f); }
00890 void swap(LowerTriangularMatrix& gm)
00891 { GeneralMatrix::swap((GeneralMatrix&)gm); }
00892 NEW_DELETE(LowerTriangularMatrix)
00893 };
00894
00896 class DiagonalMatrix : public GeneralMatrix
00897 {
00898 GeneralMatrix* Image() const;
00899 public:
00900 DiagonalMatrix() {}
00901 ~DiagonalMatrix() {}
00902 DiagonalMatrix(ArrayLengthSpecifier);
00903 DiagonalMatrix(const BaseMatrix&);
00904 DiagonalMatrix(const DiagonalMatrix& gm)
00905 : GeneralMatrix() { GetMatrix(&gm); }
00906 void operator=(const BaseMatrix&);
00907 void operator=(Real f) { GeneralMatrix::operator=(f); }
00908 void operator=(const DiagonalMatrix& m) { Eq(m); }
00909 Real& operator()(int, int);
00910 Real& operator()(int);
00911 Real operator()(int, int) const;
00912 Real operator()(int) const;
00913 Real& element(int, int);
00914 Real& element(int);
00915 Real element(int, int) const;
00916 Real element(int) const;
00917 #ifdef SETUP_C_SUBSCRIPTS
00918 Real& operator[](int m) { return store[m]; }
00919 const Real& operator[](int m) const { return store[m]; }
00920 #endif
00921 MatrixType type() const;
00922
00923 LogAndSign log_determinant() const;
00924 Real trace() const;
00925 void GetRow(MatrixRowCol&);
00926 void GetCol(MatrixRowCol&);
00927 void GetCol(MatrixColX&);
00928 void NextRow(MatrixRowCol&);
00929 void NextCol(MatrixRowCol&);
00930 void NextCol(MatrixColX&);
00931 GeneralMatrix* MakeSolver() { return this; }
00932 void Solver(MatrixColX&, const MatrixColX&);
00933 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
00934 void resize(int);
00935 void ReSize(int m) { resize(m); }
00936 void resize_keep(int);
00937 void resize(const GeneralMatrix& A);
00938 void ReSize(const GeneralMatrix& A) { resize(A); }
00939 Real* nric() const
00940 { CheckStore(); return store-1; }
00941 MatrixBandWidth bandwidth() const;
00942
00943 void operator+=(const DiagonalMatrix& M) { PlusEqual(M); }
00944 void operator-=(const DiagonalMatrix& M) { MinusEqual(M); }
00945 void operator+=(Real f) { GeneralMatrix::operator+=(f); }
00946 void operator-=(Real f) { GeneralMatrix::operator-=(f); }
00947 void swap(DiagonalMatrix& gm)
00948 { GeneralMatrix::swap((GeneralMatrix&)gm); }
00949 NEW_DELETE(DiagonalMatrix)
00950 };
00951
00953 class RowVector : public Matrix
00954 {
00955 GeneralMatrix* Image() const;
00956 public:
00957 RowVector() { nrows_val = 1; }
00958 ~RowVector() {}
00959 RowVector(ArrayLengthSpecifier n) : Matrix(1,n.Value()) {}
00960 RowVector(const BaseMatrix&);
00961 RowVector(const RowVector& gm) : Matrix() { GetMatrix(&gm); }
00962 void operator=(const BaseMatrix&);
00963 void operator=(Real f) { GeneralMatrix::operator=(f); }
00964 void operator=(const RowVector& m) { Eq(m); }
00965 Real& operator()(int);
00966 Real& element(int);
00967 Real operator()(int) const;
00968 Real element(int) const;
00969 #ifdef SETUP_C_SUBSCRIPTS
00970 Real& operator[](int m) { return store[m]; }
00971 const Real& operator[](int m) const { return store[m]; }
00972
00973 RowVector(Real a, int n) : Matrix(a, 1, n) {}
00974 RowVector(const Real* a, int n) : Matrix(a, 1, n) {}
00975 #endif
00976 MatrixType type() const;
00977 void GetCol(MatrixRowCol&);
00978 void GetCol(MatrixColX&);
00979 void NextCol(MatrixRowCol&);
00980 void NextCol(MatrixColX&);
00981 void RestoreCol(MatrixRowCol&) {}
00982 void RestoreCol(MatrixColX& c);
00983 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
00984 void resize(int);
00985 void ReSize(int m) { resize(m); }
00986 void resize_keep(int);
00987 void resize_keep(int,int);
00988 void resize(int,int);
00989 void ReSize(int m,int n) { resize(m, n); }
00990 void resize(const GeneralMatrix& A);
00991 void ReSize(const GeneralMatrix& A) { resize(A); }
00992 Real* nric() const
00993 { CheckStore(); return store-1; }
00994 void cleanup();
00995 void MiniCleanUp()
00996 { store = 0; storage = 0; nrows_val = 1; ncols_val = 0; tag_val = -1; }
00997
00998 void operator+=(const Matrix& M) { PlusEqual(M); }
00999 void operator-=(const Matrix& M) { MinusEqual(M); }
01000 void operator+=(Real f) { GeneralMatrix::Add(f); }
01001 void operator-=(Real f) { GeneralMatrix::Add(-f); }
01002 void swap(RowVector& gm)
01003 { GeneralMatrix::swap((GeneralMatrix&)gm); }
01004 NEW_DELETE(RowVector)
01005 };
01006
01008 class ColumnVector : public Matrix
01009 {
01010 GeneralMatrix* Image() const;
01011 public:
01012 ColumnVector() { ncols_val = 1; }
01013 ~ColumnVector() {}
01014 ColumnVector(ArrayLengthSpecifier n) : Matrix(n.Value(),1) {}
01015 ColumnVector(const BaseMatrix&);
01016 ColumnVector(const ColumnVector& gm) : Matrix() { GetMatrix(&gm); }
01017 void operator=(const BaseMatrix&);
01018 void operator=(Real f) { GeneralMatrix::operator=(f); }
01019 void operator=(const ColumnVector& m) { Eq(m); }
01020 Real& operator()(int);
01021 Real& element(int);
01022 Real operator()(int) const;
01023 Real element(int) const;
01024 #ifdef SETUP_C_SUBSCRIPTS
01025 Real& operator[](int m) { return store[m]; }
01026 const Real& operator[](int m) const { return store[m]; }
01027
01028 ColumnVector(Real a, int m) : Matrix(a, m, 1) {}
01029 ColumnVector(const Real* a, int m) : Matrix(a, m, 1) {}
01030 #endif
01031 MatrixType type() const;
01032 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
01033 void resize(int);
01034 void ReSize(int m) { resize(m); }
01035 void resize_keep(int);
01036 void resize_keep(int,int);
01037 void resize(int,int);
01038 void ReSize(int m,int n) { resize(m, n); }
01039 void resize(const GeneralMatrix& A);
01040 void ReSize(const GeneralMatrix& A) { resize(A); }
01041 Real* nric() const
01042 { CheckStore(); return store-1; }
01043 void cleanup();
01044 void MiniCleanUp()
01045 { store = 0; storage = 0; nrows_val = 0; ncols_val = 1; tag_val = -1; }
01046
01047 void operator+=(const Matrix& M) { PlusEqual(M); }
01048 void operator-=(const Matrix& M) { MinusEqual(M); }
01049 void operator+=(Real f) { GeneralMatrix::Add(f); }
01050 void operator-=(Real f) { GeneralMatrix::Add(-f); }
01051 void swap(ColumnVector& gm)
01052 { GeneralMatrix::swap((GeneralMatrix&)gm); }
01053 NEW_DELETE(ColumnVector)
01054 };
01055
01059 class CroutMatrix : public GeneralMatrix
01060 {
01061 int* indx;
01062 bool d;
01063 bool sing;
01064 void ludcmp();
01065 void get_aux(CroutMatrix&);
01066 GeneralMatrix* Image() const;
01067 public:
01068 CroutMatrix(const BaseMatrix&);
01069 CroutMatrix() : indx(0), d(true), sing(true) {}
01070 CroutMatrix(const CroutMatrix&);
01071 void operator=(const CroutMatrix&);
01072 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01073 MatrixType type() const;
01074 void lubksb(Real*, int=0);
01075 ~CroutMatrix();
01076 GeneralMatrix* MakeSolver() { return this; }
01077 LogAndSign log_determinant() const;
01078 void Solver(MatrixColX&, const MatrixColX&);
01079 void GetRow(MatrixRowCol&);
01080 void GetCol(MatrixRowCol&);
01081 void GetCol(MatrixColX& c) { GetCol((MatrixRowCol&)c); }
01082 void cleanup();
01083 void MiniCleanUp();
01084 bool IsEqual(const GeneralMatrix&) const;
01085 bool is_singular() const { return sing; }
01086 bool IsSingular() const { return sing; }
01087 const int* const_data_indx() const { return indx; }
01088 bool even_exchanges() const { return d; }
01089 void swap(CroutMatrix& gm);
01090 NEW_DELETE(CroutMatrix)
01091 };
01092
01093
01094
01096 class BandMatrix : public GeneralMatrix
01097 {
01098 GeneralMatrix* Image() const;
01099 protected:
01100 void CornerClear() const;
01101 short SimpleAddOK(const GeneralMatrix* gm);
01102 public:
01103 int lower_val, upper_val;
01104 BandMatrix() { lower_val=0; upper_val=0; CornerClear(); }
01105 ~BandMatrix() {}
01106 BandMatrix(int n,int lb,int ub) { resize(n,lb,ub); CornerClear(); }
01107
01108 BandMatrix(const BaseMatrix&);
01109 void operator=(const BaseMatrix&);
01110 void operator=(Real f) { GeneralMatrix::operator=(f); }
01111 void operator=(const BandMatrix& m) { Eq(m); }
01112 MatrixType type() const;
01113 Real& operator()(int, int);
01114 Real& element(int, int);
01115 Real operator()(int, int) const;
01116 Real element(int, int) const;
01117 #ifdef SETUP_C_SUBSCRIPTS
01118 Real* operator[](int m) { return store+(upper_val+lower_val)*m+lower_val; }
01119 const Real* operator[](int m) const
01120 { return store+(upper_val+lower_val)*m+lower_val; }
01121 #endif
01122 BandMatrix(const BandMatrix& gm) : GeneralMatrix() { GetMatrix(&gm); }
01123 LogAndSign log_determinant() const;
01124 GeneralMatrix* MakeSolver();
01125 Real trace() const;
01126 Real sum_square() const
01127 { CornerClear(); return GeneralMatrix::sum_square(); }
01128 Real sum_absolute_value() const
01129 { CornerClear(); return GeneralMatrix::sum_absolute_value(); }
01130 Real sum() const
01131 { CornerClear(); return GeneralMatrix::sum(); }
01132 Real maximum_absolute_value() const
01133 { CornerClear(); return GeneralMatrix::maximum_absolute_value(); }
01134 Real minimum_absolute_value() const
01135 { int i, j; return GeneralMatrix::minimum_absolute_value2(i, j); }
01136 Real maximum() const { int i, j; return GeneralMatrix::maximum2(i, j); }
01137 Real minimum() const { int i, j; return GeneralMatrix::minimum2(i, j); }
01138 void GetRow(MatrixRowCol&);
01139 void GetCol(MatrixRowCol&);
01140 void GetCol(MatrixColX&);
01141 void RestoreCol(MatrixRowCol&);
01142 void RestoreCol(MatrixColX& c) { RestoreCol((MatrixRowCol&)c); }
01143 void NextRow(MatrixRowCol&);
01144 virtual void resize(int, int, int);
01145 virtual void ReSize(int m, int n, int b) { resize(m, n, b); }
01146 void resize(const GeneralMatrix& A);
01147 void ReSize(const GeneralMatrix& A) { resize(A); }
01148
01149
01150
01151 MatrixBandWidth bandwidth() const;
01152 void SetParameters(const GeneralMatrix*);
01153 MatrixInput operator<<(double);
01154 MatrixInput operator<<(float);
01155 MatrixInput operator<<(int f);
01156 void operator<<(const double* r);
01157 void operator<<(const float* r);
01158 void operator<<(const int* r);
01159
01160
01161 void operator<<(const BaseMatrix& X) { GeneralMatrix::operator<<(X); }
01162 void swap(BandMatrix& gm);
01163 NEW_DELETE(BandMatrix)
01164 };
01165
01167 class UpperBandMatrix : public BandMatrix
01168 {
01169 GeneralMatrix* Image() const;
01170 public:
01171 UpperBandMatrix() {}
01172 ~UpperBandMatrix() {}
01173 UpperBandMatrix(int n, int ubw)
01174 : BandMatrix(n, 0, ubw) {}
01175 UpperBandMatrix(const BaseMatrix&);
01176 void operator=(const BaseMatrix&);
01177 void operator=(Real f) { GeneralMatrix::operator=(f); }
01178 void operator=(const UpperBandMatrix& m) { Eq(m); }
01179 MatrixType type() const;
01180 UpperBandMatrix(const UpperBandMatrix& gm) : BandMatrix() { GetMatrix(&gm); }
01181 GeneralMatrix* MakeSolver() { return this; }
01182 void Solver(MatrixColX&, const MatrixColX&);
01183 LogAndSign log_determinant() const;
01184 void resize(int, int, int);
01185 void ReSize(int m, int n, int b) { resize(m, n, b); }
01186 void resize(int n,int ubw)
01187 { BandMatrix::resize(n,0,ubw); }
01188 void ReSize(int n,int ubw)
01189 { BandMatrix::resize(n,0,ubw); }
01190 void resize(const GeneralMatrix& A) { BandMatrix::resize(A); }
01191 void ReSize(const GeneralMatrix& A) { BandMatrix::resize(A); }
01192 Real& operator()(int, int);
01193 Real operator()(int, int) const;
01194 Real& element(int, int);
01195 Real element(int, int) const;
01196 #ifdef SETUP_C_SUBSCRIPTS
01197 Real* operator[](int m) { return store+upper_val*m; }
01198 const Real* operator[](int m) const { return store+upper_val*m; }
01199 #endif
01200 void swap(UpperBandMatrix& gm)
01201 { BandMatrix::swap((BandMatrix&)gm); }
01202 NEW_DELETE(UpperBandMatrix)
01203 };
01204
01206 class LowerBandMatrix : public BandMatrix
01207 {
01208 GeneralMatrix* Image() const;
01209 public:
01210 LowerBandMatrix() {}
01211 ~LowerBandMatrix() {}
01212 LowerBandMatrix(int n, int lbw)
01213 : BandMatrix(n, lbw, 0) {}
01214 LowerBandMatrix(const BaseMatrix&);
01215 void operator=(const BaseMatrix&);
01216 void operator=(Real f) { GeneralMatrix::operator=(f); }
01217 void operator=(const LowerBandMatrix& m) { Eq(m); }
01218 MatrixType type() const;
01219 LowerBandMatrix(const LowerBandMatrix& gm) : BandMatrix() { GetMatrix(&gm); }
01220 GeneralMatrix* MakeSolver() { return this; }
01221 void Solver(MatrixColX&, const MatrixColX&);
01222 LogAndSign log_determinant() const;
01223 void resize(int, int, int);
01224 void ReSize(int m, int n, int b) { resize(m, n, b); }
01225 void resize(int n,int lbw)
01226 { BandMatrix::resize(n,lbw,0); }
01227 void ReSize(int n,int lbw)
01228 { BandMatrix::resize(n,lbw,0); }
01229 void resize(const GeneralMatrix& A) { BandMatrix::resize(A); }
01230 void ReSize(const GeneralMatrix& A) { BandMatrix::resize(A); }
01231 Real& operator()(int, int);
01232 Real operator()(int, int) const;
01233 Real& element(int, int);
01234 Real element(int, int) const;
01235 #ifdef SETUP_C_SUBSCRIPTS
01236 Real* operator[](int m) { return store+lower_val*(m+1); }
01237 const Real* operator[](int m) const { return store+lower_val*(m+1); }
01238 #endif
01239 void swap(LowerBandMatrix& gm)
01240 { BandMatrix::swap((BandMatrix&)gm); }
01241 NEW_DELETE(LowerBandMatrix)
01242 };
01243
01245 class SymmetricBandMatrix : public GeneralMatrix
01246 {
01247 GeneralMatrix* Image() const;
01248 void CornerClear() const;
01249 short SimpleAddOK(const GeneralMatrix* gm);
01250 public:
01251 int lower_val;
01252 SymmetricBandMatrix() { lower_val=0; CornerClear(); }
01253 ~SymmetricBandMatrix() {}
01254 SymmetricBandMatrix(int n, int lb) { resize(n,lb); CornerClear(); }
01255 SymmetricBandMatrix(const BaseMatrix&);
01256 void operator=(const BaseMatrix&);
01257 void operator=(Real f) { GeneralMatrix::operator=(f); }
01258 void operator=(const SymmetricBandMatrix& m) { Eq(m); }
01259 Real& operator()(int, int);
01260 Real& element(int, int);
01261 Real operator()(int, int) const;
01262 Real element(int, int) const;
01263 #ifdef SETUP_C_SUBSCRIPTS
01264 Real* operator[](int m) { return store+lower_val*(m+1); }
01265 const Real* operator[](int m) const { return store+lower_val*(m+1); }
01266 #endif
01267 MatrixType type() const;
01268 SymmetricBandMatrix(const SymmetricBandMatrix& gm)
01269 : GeneralMatrix() { GetMatrix(&gm); }
01270 GeneralMatrix* MakeSolver();
01271 Real sum_square() const;
01272 Real sum_absolute_value() const;
01273 Real sum() const;
01274 Real maximum_absolute_value() const
01275 { CornerClear(); return GeneralMatrix::maximum_absolute_value(); }
01276 Real minimum_absolute_value() const
01277 { int i, j; return GeneralMatrix::minimum_absolute_value2(i, j); }
01278 Real maximum() const { int i, j; return GeneralMatrix::maximum2(i, j); }
01279 Real minimum() const { int i, j; return GeneralMatrix::minimum2(i, j); }
01280 Real trace() const;
01281 LogAndSign log_determinant() const;
01282 void GetRow(MatrixRowCol&);
01283 void GetCol(MatrixRowCol&);
01284 void GetCol(MatrixColX&);
01285 void RestoreCol(MatrixRowCol&) {}
01286 void RestoreCol(MatrixColX&);
01287 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
01288 void resize(int,int);
01289 void ReSize(int m,int b) { resize(m, b); }
01290 void resize(const GeneralMatrix& A);
01291 void ReSize(const GeneralMatrix& A) { resize(A); }
01292
01293
01294
01295 MatrixBandWidth bandwidth() const;
01296 void SetParameters(const GeneralMatrix*);
01297 void operator<<(const double* r);
01298 void operator<<(const float* r);
01299 void operator<<(const int* r);
01300 void operator<<(const BaseMatrix& X) { GeneralMatrix::operator<<(X); }
01301 void swap(SymmetricBandMatrix& gm);
01302 NEW_DELETE(SymmetricBandMatrix)
01303 };
01304
01306 class BandLUMatrix : public GeneralMatrix
01307 {
01308 int* indx;
01309 bool d;
01310 bool sing;
01311 Real* store2;
01312 int storage2;
01313 int m1,m2;
01314 void ludcmp();
01315 void get_aux(BandLUMatrix&);
01316 GeneralMatrix* Image() const;
01317 public:
01318 BandLUMatrix(const BaseMatrix&);
01319 BandLUMatrix()
01320 : indx(0), d(true), sing(true), store2(0), storage2(0), m1(0), m2(0) {}
01321 BandLUMatrix(const BandLUMatrix&);
01322 void operator=(const BandLUMatrix&);
01323 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01324 MatrixType type() const;
01325 void lubksb(Real*, int=0);
01326 ~BandLUMatrix();
01327 GeneralMatrix* MakeSolver() { return this; }
01328 LogAndSign log_determinant() const;
01329 void Solver(MatrixColX&, const MatrixColX&);
01330 void GetRow(MatrixRowCol&);
01331 void GetCol(MatrixRowCol&);
01332 void GetCol(MatrixColX& c) { GetCol((MatrixRowCol&)c); }
01333 void cleanup();
01334 void MiniCleanUp();
01335 bool IsEqual(const GeneralMatrix&) const;
01336 bool is_singular() const { return sing; }
01337 bool IsSingular() const { return sing; }
01338 const Real* const_data2() const { return store2; }
01339 int size2() const { return storage2; }
01340 const int* const_data_indx() const { return indx; }
01341 bool even_exchanges() const { return d; }
01342 MatrixBandWidth bandwidth() const;
01343 void swap(BandLUMatrix& gm);
01344 NEW_DELETE(BandLUMatrix)
01345 };
01346
01347
01348
01350 class IdentityMatrix : public GeneralMatrix
01351 {
01352 GeneralMatrix* Image() const;
01353 public:
01354 IdentityMatrix() {}
01355 ~IdentityMatrix() {}
01356 IdentityMatrix(ArrayLengthSpecifier n) : GeneralMatrix(1)
01357 { nrows_val = ncols_val = n.Value(); *store = 1; }
01358 IdentityMatrix(const IdentityMatrix& gm)
01359 : GeneralMatrix() { GetMatrix(&gm); }
01360 IdentityMatrix(const BaseMatrix&);
01361 void operator=(const BaseMatrix&);
01362 void operator=(const IdentityMatrix& m) { Eq(m); }
01363 void operator=(Real f) { GeneralMatrix::operator=(f); }
01364 MatrixType type() const;
01365
01366 LogAndSign log_determinant() const;
01367 Real trace() const;
01368 Real sum_square() const;
01369 Real sum_absolute_value() const;
01370 Real sum() const { return trace(); }
01371 void GetRow(MatrixRowCol&);
01372 void GetCol(MatrixRowCol&);
01373 void GetCol(MatrixColX&);
01374 void NextRow(MatrixRowCol&);
01375 void NextCol(MatrixRowCol&);
01376 void NextCol(MatrixColX&);
01377 GeneralMatrix* MakeSolver() { return this; }
01378 void Solver(MatrixColX&, const MatrixColX&);
01379 GeneralMatrix* Transpose(TransposedMatrix*, MatrixType);
01380 void resize(int n);
01381 void ReSize(int n) { resize(n); }
01382 void resize(const GeneralMatrix& A);
01383 void ReSize(const GeneralMatrix& A) { resize(A); }
01384 MatrixBandWidth bandwidth() const;
01385
01386 void swap(IdentityMatrix& gm)
01387 { GeneralMatrix::swap((GeneralMatrix&)gm); }
01388 NEW_DELETE(IdentityMatrix)
01389 };
01390
01391
01392
01393
01394
01395
01397 class GenericMatrix : public BaseMatrix
01398 {
01399 GeneralMatrix* gm;
01400 int search(const BaseMatrix* bm) const;
01401 friend class BaseMatrix;
01402 public:
01403 GenericMatrix() : gm(0) {}
01404 GenericMatrix(const BaseMatrix& bm)
01405 { gm = ((BaseMatrix&)bm).Evaluate(); gm = gm->Image(); }
01406 GenericMatrix(const GenericMatrix& bm) : BaseMatrix()
01407 { gm = bm.gm->Image(); }
01408 void operator=(const GenericMatrix&);
01409 void operator=(const BaseMatrix&);
01410 void operator+=(const BaseMatrix&);
01411 void operator-=(const BaseMatrix&);
01412 void operator*=(const BaseMatrix&);
01413 void operator|=(const BaseMatrix&);
01414 void operator&=(const BaseMatrix&);
01415 void operator+=(Real);
01416 void operator-=(Real r) { operator+=(-r); }
01417 void operator*=(Real);
01418 void operator/=(Real r) { operator*=(1.0/r); }
01419 ~GenericMatrix() { delete gm; }
01420 void cleanup() { delete gm; gm = 0; }
01421 void Release() { gm->Release(); }
01422 void release() { gm->release(); }
01423 GeneralMatrix* Evaluate(MatrixType = MatrixTypeUnSp);
01424 MatrixBandWidth bandwidth() const;
01425 void swap(GenericMatrix& x);
01426 NEW_DELETE(GenericMatrix)
01427 };
01428
01429
01430
01433 class MultipliedMatrix : public BaseMatrix
01434 {
01435 protected:
01436
01437
01438 union { const BaseMatrix* bm1; GeneralMatrix* gm1; };
01439
01440 union { const BaseMatrix* bm2; GeneralMatrix* gm2; };
01441 MultipliedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01442 : bm1(bm1x),bm2(bm2x) {}
01443 int search(const BaseMatrix*) const;
01444 friend class BaseMatrix;
01445 friend class GeneralMatrix;
01446 friend class GenericMatrix;
01447 public:
01448 ~MultipliedMatrix() {}
01449 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01450 MatrixBandWidth bandwidth() const;
01451 NEW_DELETE(MultipliedMatrix)
01452 };
01453
01456 class AddedMatrix : public MultipliedMatrix
01457 {
01458 protected:
01459 AddedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01460 : MultipliedMatrix(bm1x,bm2x) {}
01461
01462 friend class BaseMatrix;
01463 friend class GeneralMatrix;
01464 friend class GenericMatrix;
01465 public:
01466 ~AddedMatrix() {}
01467 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01468 MatrixBandWidth bandwidth() const;
01469 NEW_DELETE(AddedMatrix)
01470 };
01471
01474 class SPMatrix : public AddedMatrix
01475 {
01476 protected:
01477 SPMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01478 : AddedMatrix(bm1x,bm2x) {}
01479
01480 friend class BaseMatrix;
01481 friend class GeneralMatrix;
01482 friend class GenericMatrix;
01483 public:
01484 ~SPMatrix() {}
01485 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01486 MatrixBandWidth bandwidth() const;
01487
01488 friend SPMatrix SP(const BaseMatrix&, const BaseMatrix&);
01489
01490 NEW_DELETE(SPMatrix)
01491 };
01492
01495 class KPMatrix : public MultipliedMatrix
01496 {
01497 protected:
01498 KPMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01499 : MultipliedMatrix(bm1x,bm2x) {}
01500
01501 friend class BaseMatrix;
01502 friend class GeneralMatrix;
01503 friend class GenericMatrix;
01504 public:
01505 ~KPMatrix() {}
01506 MatrixBandWidth bandwidth() const;
01507 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01508 friend KPMatrix KP(const BaseMatrix&, const BaseMatrix&);
01509 NEW_DELETE(KPMatrix)
01510 };
01511
01514 class ConcatenatedMatrix : public MultipliedMatrix
01515 {
01516 protected:
01517 ConcatenatedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01518 : MultipliedMatrix(bm1x,bm2x) {}
01519
01520 friend class BaseMatrix;
01521 friend class GeneralMatrix;
01522 friend class GenericMatrix;
01523 public:
01524 ~ConcatenatedMatrix() {}
01525 MatrixBandWidth bandwidth() const;
01526 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01527 NEW_DELETE(ConcatenatedMatrix)
01528 };
01529
01532 class StackedMatrix : public ConcatenatedMatrix
01533 {
01534 protected:
01535 StackedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01536 : ConcatenatedMatrix(bm1x,bm2x) {}
01537
01538 friend class BaseMatrix;
01539 friend class GeneralMatrix;
01540 friend class GenericMatrix;
01541 public:
01542 ~StackedMatrix() {}
01543 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01544 NEW_DELETE(StackedMatrix)
01545 };
01546
01549 class SolvedMatrix : public MultipliedMatrix
01550 {
01551 SolvedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01552 : MultipliedMatrix(bm1x,bm2x) {}
01553 friend class BaseMatrix;
01554 friend class InvertedMatrix;
01555 public:
01556 ~SolvedMatrix() {}
01557 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01558 MatrixBandWidth bandwidth() const;
01559 NEW_DELETE(SolvedMatrix)
01560 };
01561
01564 class SubtractedMatrix : public AddedMatrix
01565 {
01566 SubtractedMatrix(const BaseMatrix* bm1x, const BaseMatrix* bm2x)
01567 : AddedMatrix(bm1x,bm2x) {}
01568 friend class BaseMatrix;
01569 friend class GeneralMatrix;
01570 friend class GenericMatrix;
01571 public:
01572 ~SubtractedMatrix() {}
01573 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01574 NEW_DELETE(SubtractedMatrix)
01575 };
01576
01579 class ShiftedMatrix : public BaseMatrix
01580 {
01581 protected:
01582 union { const BaseMatrix* bm; GeneralMatrix* gm; };
01583 Real f;
01584 ShiftedMatrix(const BaseMatrix* bmx, Real fx) : bm(bmx),f(fx) {}
01585 int search(const BaseMatrix*) const;
01586 friend class BaseMatrix;
01587 friend class GeneralMatrix;
01588 friend class GenericMatrix;
01589 public:
01590 ~ShiftedMatrix() {}
01591 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01592 friend ShiftedMatrix operator+(Real f, const BaseMatrix& BM);
01593 NEW_DELETE(ShiftedMatrix)
01594 };
01595
01598 class NegShiftedMatrix : public ShiftedMatrix
01599 {
01600 protected:
01601 NegShiftedMatrix(Real fx, const BaseMatrix* bmx) : ShiftedMatrix(bmx,fx) {}
01602 friend class BaseMatrix;
01603 friend class GeneralMatrix;
01604 friend class GenericMatrix;
01605 public:
01606 ~NegShiftedMatrix() {}
01607 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01608 friend NegShiftedMatrix operator-(Real, const BaseMatrix&);
01609 NEW_DELETE(NegShiftedMatrix)
01610 };
01611
01614 class ScaledMatrix : public ShiftedMatrix
01615 {
01616 ScaledMatrix(const BaseMatrix* bmx, Real fx) : ShiftedMatrix(bmx,fx) {}
01617 friend class BaseMatrix;
01618 friend class GeneralMatrix;
01619 friend class GenericMatrix;
01620 public:
01621 ~ScaledMatrix() {}
01622 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01623 MatrixBandWidth bandwidth() const;
01624 friend ScaledMatrix operator*(Real f, const BaseMatrix& BM);
01625 NEW_DELETE(ScaledMatrix)
01626 };
01627
01630 class NegatedMatrix : public BaseMatrix
01631 {
01632 protected:
01633 union { const BaseMatrix* bm; GeneralMatrix* gm; };
01634 NegatedMatrix(const BaseMatrix* bmx) : bm(bmx) {}
01635 int search(const BaseMatrix*) const;
01636 private:
01637 friend class BaseMatrix;
01638 public:
01639 ~NegatedMatrix() {}
01640 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01641 MatrixBandWidth bandwidth() const;
01642 NEW_DELETE(NegatedMatrix)
01643 };
01644
01647 class TransposedMatrix : public NegatedMatrix
01648 {
01649 TransposedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01650 friend class BaseMatrix;
01651 public:
01652 ~TransposedMatrix() {}
01653 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01654 MatrixBandWidth bandwidth() const;
01655 NEW_DELETE(TransposedMatrix)
01656 };
01657
01660 class ReversedMatrix : public NegatedMatrix
01661 {
01662 ReversedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01663 friend class BaseMatrix;
01664 public:
01665 ~ReversedMatrix() {}
01666 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01667 NEW_DELETE(ReversedMatrix)
01668 };
01669
01672 class InvertedMatrix : public NegatedMatrix
01673 {
01674 InvertedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01675 public:
01676 ~InvertedMatrix() {}
01677 SolvedMatrix operator*(const BaseMatrix&) const;
01678 ScaledMatrix operator*(Real t) const { return BaseMatrix::operator*(t); }
01679 friend class BaseMatrix;
01680 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01681 MatrixBandWidth bandwidth() const;
01682 NEW_DELETE(InvertedMatrix)
01683 };
01684
01687 class RowedMatrix : public NegatedMatrix
01688 {
01689 RowedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01690 friend class BaseMatrix;
01691 public:
01692 ~RowedMatrix() {}
01693 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01694 MatrixBandWidth bandwidth() const;
01695 NEW_DELETE(RowedMatrix)
01696 };
01697
01700 class ColedMatrix : public NegatedMatrix
01701 {
01702 ColedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01703 friend class BaseMatrix;
01704 public:
01705 ~ColedMatrix() {}
01706 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01707 MatrixBandWidth bandwidth() const;
01708 NEW_DELETE(ColedMatrix)
01709 };
01710
01713 class DiagedMatrix : public NegatedMatrix
01714 {
01715 DiagedMatrix(const BaseMatrix* bmx) : NegatedMatrix(bmx) {}
01716 friend class BaseMatrix;
01717 public:
01718 ~DiagedMatrix() {}
01719 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01720 MatrixBandWidth bandwidth() const;
01721 NEW_DELETE(DiagedMatrix)
01722 };
01723
01726 class MatedMatrix : public NegatedMatrix
01727 {
01728 int nr, nc;
01729 MatedMatrix(const BaseMatrix* bmx, int nrx, int ncx)
01730 : NegatedMatrix(bmx), nr(nrx), nc(ncx) {}
01731 friend class BaseMatrix;
01732 public:
01733 ~MatedMatrix() {}
01734 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01735 MatrixBandWidth bandwidth() const;
01736 NEW_DELETE(MatedMatrix)
01737 };
01738
01741 class ReturnMatrix : public BaseMatrix
01742 {
01743 GeneralMatrix* gm;
01744 int search(const BaseMatrix*) const;
01745 public:
01746 ~ReturnMatrix() {}
01747 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01748 friend class BaseMatrix;
01749 ReturnMatrix(const ReturnMatrix& tm) : BaseMatrix(), gm(tm.gm) {}
01750 ReturnMatrix(const GeneralMatrix* gmx) : gm((GeneralMatrix*&)gmx) {}
01751
01752 MatrixBandWidth bandwidth() const;
01753 NEW_DELETE(ReturnMatrix)
01754 };
01755
01756
01757
01758
01761 class GetSubMatrix : public NegatedMatrix
01762 {
01763 int row_skip;
01764 int row_number;
01765 int col_skip;
01766 int col_number;
01767 bool IsSym;
01768
01769 GetSubMatrix
01770 (const BaseMatrix* bmx, int rs, int rn, int cs, int cn, bool is)
01771 : NegatedMatrix(bmx),
01772 row_skip(rs), row_number(rn), col_skip(cs), col_number(cn), IsSym(is) {}
01773 void SetUpLHS();
01774 friend class BaseMatrix;
01775 public:
01776 GetSubMatrix(const GetSubMatrix& g)
01777 : NegatedMatrix(g.bm), row_skip(g.row_skip), row_number(g.row_number),
01778 col_skip(g.col_skip), col_number(g.col_number), IsSym(g.IsSym) {}
01779 ~GetSubMatrix() {}
01780 GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp);
01781 void operator=(const BaseMatrix&);
01782 void operator+=(const BaseMatrix&);
01783 void operator-=(const BaseMatrix&);
01784 void operator=(const GetSubMatrix& m) { operator=((const BaseMatrix&)m); }
01785 void operator<<(const BaseMatrix&);
01786 void operator<<(const double*);
01787 void operator<<(const float*);
01788 void operator<<(const int*);
01789 MatrixInput operator<<(double);
01790 MatrixInput operator<<(float);
01791 MatrixInput operator<<(int f);
01792 void operator=(Real);
01793 void operator+=(Real);
01794 void operator-=(Real r) { operator+=(-r); }
01795 void operator*=(Real);
01796 void operator/=(Real r) { operator*=(1.0/r); }
01797 void inject(const GeneralMatrix&);
01798 void Inject(const GeneralMatrix& GM) { inject(GM); }
01799 MatrixBandWidth bandwidth() const;
01800 NEW_DELETE(GetSubMatrix)
01801 };
01802
01803
01804
01809 class LinearEquationSolver : public BaseMatrix
01810 {
01811 GeneralMatrix* gm;
01812 int search(const BaseMatrix*) const { return 0; }
01813 friend class BaseMatrix;
01814 public:
01815 LinearEquationSolver(const BaseMatrix& bm);
01816 ~LinearEquationSolver() { delete gm; }
01817 void cleanup() { delete gm; }
01818 GeneralMatrix* Evaluate(MatrixType) { return gm; }
01819
01820 NEW_DELETE(LinearEquationSolver)
01821 };
01822
01823
01824
01828
01829 class MatrixInput
01830 {
01831 int n;
01832 Real* r;
01833 public:
01834 MatrixInput(const MatrixInput& mi) : n(mi.n), r(mi.r) {}
01835 MatrixInput(int nx, Real* rx) : n(nx), r(rx) {}
01836 ~MatrixInput();
01837 MatrixInput operator<<(double);
01838 MatrixInput operator<<(float);
01839 MatrixInput operator<<(int f);
01840 friend class GeneralMatrix;
01841 };
01842
01843
01844
01845
01846
01851
01852 class SimpleIntArray : public Janitor
01853 {
01854 protected:
01855 int* a;
01856 int n;
01857 public:
01858 SimpleIntArray(int xn);
01859 SimpleIntArray() : a(0), n(0) {}
01860 ~SimpleIntArray();
01861 int& operator[](int i);
01862 int operator[](int i) const;
01864 void operator=(int ai);
01865 void operator=(const SimpleIntArray& b);
01867 SimpleIntArray(const SimpleIntArray& b);
01869 int Size() const { return n; }
01871 int size() const { return n; }
01873 int* Data() { return a; }
01874 const int* Data() const { return a; }
01875 int* data() { return a; }
01876 const int* data() const { return a; }
01877 const int* const_data() const { return a; }
01878 void resize(int i, bool keep = false);
01880 void ReSize(int i, bool keep = false) { resize(i, keep); }
01882 void resize_keep(int i) { resize(i, true); }
01884 void cleanup() { resize(0); }
01885 void CleanUp() { resize(0); }
01886 NEW_DELETE(SimpleIntArray)
01887 };
01888
01889
01890
01892 class RealStarStar
01893 {
01894 Real** a;
01895 public:
01896 RealStarStar(Matrix& A);
01897 ~RealStarStar() { delete [] a; }
01898 operator Real**() { return a; }
01899 };
01900
01902 class ConstRealStarStar
01903 {
01904 const Real** a;
01905 public:
01906 ConstRealStarStar(const Matrix& A);
01907 ~ConstRealStarStar() { delete [] a; }
01908 operator const Real**() { return a; }
01909 };
01910
01911
01912
01914 class NPDException : public Runtime_error
01915 {
01916 public:
01917 static unsigned long Select;
01918 NPDException(const GeneralMatrix&);
01919 };
01920
01922 class ConvergenceException : public Runtime_error
01923 {
01924 public:
01925 static unsigned long Select;
01926 ConvergenceException(const GeneralMatrix& A);
01927 ConvergenceException(const char* c);
01928 };
01929
01931 class SingularException : public Runtime_error
01932 {
01933 public:
01934 static unsigned long Select;
01935 SingularException(const GeneralMatrix& A);
01936 };
01937
01939 class OverflowException : public Runtime_error
01940 {
01941 public:
01942 static unsigned long Select;
01943 OverflowException(const char* c);
01944 };
01945
01947 class ProgramException : public Logic_error
01948 {
01949 protected:
01950 ProgramException();
01951 public:
01952 static unsigned long Select;
01953 ProgramException(const char* c);
01954 ProgramException(const char* c, const GeneralMatrix&);
01955 ProgramException(const char* c, const GeneralMatrix&, const GeneralMatrix&);
01956 ProgramException(const char* c, MatrixType, MatrixType);
01957 };
01958
01960 class IndexException : public Logic_error
01961 {
01962 public:
01963 static unsigned long Select;
01964 IndexException(int i, const GeneralMatrix& A);
01965 IndexException(int i, int j, const GeneralMatrix& A);
01966
01967 IndexException(int i, const GeneralMatrix& A, bool);
01968 IndexException(int i, int j, const GeneralMatrix& A, bool);
01969 };
01970
01972 class VectorException : public Logic_error
01973 {
01974 public:
01975 static unsigned long Select;
01976 VectorException();
01977 VectorException(const GeneralMatrix& A);
01978 };
01979
01981 class NotSquareException : public Logic_error
01982 {
01983 public:
01984 static unsigned long Select;
01985 NotSquareException(const GeneralMatrix& A);
01986 NotSquareException();
01987 };
01988
01990 class SubMatrixDimensionException : public Logic_error
01991 {
01992 public:
01993 static unsigned long Select;
01994 SubMatrixDimensionException();
01995 };
01996
01998 class IncompatibleDimensionsException : public Logic_error
01999 {
02000 public:
02001 static unsigned long Select;
02002 IncompatibleDimensionsException();
02003 IncompatibleDimensionsException(const GeneralMatrix&);
02004 IncompatibleDimensionsException(const GeneralMatrix&, const GeneralMatrix&);
02005 };
02006
02008 class NotDefinedException : public Logic_error
02009 {
02010 public:
02011 static unsigned long Select;
02012 NotDefinedException(const char* op, const char* matrix);
02013 };
02014
02016 class CannotBuildException : public Logic_error
02017 {
02018 public:
02019 static unsigned long Select;
02020 CannotBuildException(const char* matrix);
02021 };
02022
02023
02025 class InternalException : public Logic_error
02026 {
02027 public:
02028 static unsigned long Select;
02029 InternalException(const char* c);
02030 };
02031
02032
02033
02034 bool operator==(const GeneralMatrix& A, const GeneralMatrix& B);
02035 bool operator==(const BaseMatrix& A, const BaseMatrix& B);
02036 inline bool operator!=(const GeneralMatrix& A, const GeneralMatrix& B)
02037 { return ! (A==B); }
02038 inline bool operator!=(const BaseMatrix& A, const BaseMatrix& B)
02039 { return ! (A==B); }
02040
02041
02042
02043 inline bool operator<=(const BaseMatrix& A, const BaseMatrix&)
02044 { A.IEQND(); return true; }
02045 inline bool operator>=(const BaseMatrix& A, const BaseMatrix&)
02046 { A.IEQND(); return true; }
02047 inline bool operator<(const BaseMatrix& A, const BaseMatrix&)
02048 { A.IEQND(); return true; }
02049 inline bool operator>(const BaseMatrix& A, const BaseMatrix&)
02050 { A.IEQND(); return true; }
02051
02052 bool is_zero(const BaseMatrix& A);
02053 inline bool IsZero(const BaseMatrix& A) { return is_zero(A); }
02054
02055 Real dotproduct(const Matrix& A, const Matrix& B);
02056 Matrix crossproduct(const Matrix& A, const Matrix& B);
02057 ReturnMatrix crossproduct_rows(const Matrix& A, const Matrix& B);
02058 ReturnMatrix crossproduct_columns(const Matrix& A, const Matrix& B);
02059
02060 inline Real DotProduct(const Matrix& A, const Matrix& B)
02061 { return dotproduct(A, B); }
02062 inline Matrix CrossProduct(const Matrix& A, const Matrix& B)
02063 { return crossproduct(A, B); }
02064 inline ReturnMatrix CrossProductRows(const Matrix& A, const Matrix& B)
02065 { return crossproduct_rows(A, B); }
02066 inline ReturnMatrix CrossProductColumns(const Matrix& A, const Matrix& B)
02067 { return crossproduct_columns(A, B); }
02068
02069 void newmat_block_copy(int n, Real* from, Real* to);
02070
02071
02072
02073
02074
02075 bool Rectangular(MatrixType a, MatrixType b, MatrixType c);
02076 bool Compare(const MatrixType&, MatrixType&);
02077 Real dotproduct(const Matrix& A, const Matrix& B);
02078 SPMatrix SP(const BaseMatrix&, const BaseMatrix&);
02079 KPMatrix KP(const BaseMatrix&, const BaseMatrix&);
02080 ShiftedMatrix operator+(Real f, const BaseMatrix& BM);
02081 NegShiftedMatrix operator-(Real, const BaseMatrix&);
02082 ScaledMatrix operator*(Real f, const BaseMatrix& BM);
02083
02084
02085
02086 inline LogAndSign log_determinant(const BaseMatrix& B)
02087 { return B.log_determinant(); }
02088 inline LogAndSign LogDeterminant(const BaseMatrix& B)
02089 { return B.log_determinant(); }
02090 inline Real determinant(const BaseMatrix& B)
02091 { return B.determinant(); }
02092 inline Real Determinant(const BaseMatrix& B)
02093 { return B.determinant(); }
02094 inline Real sum_square(const BaseMatrix& B) { return B.sum_square(); }
02095 inline Real SumSquare(const BaseMatrix& B) { return B.sum_square(); }
02096 inline Real norm_Frobenius(const BaseMatrix& B) { return B.norm_Frobenius(); }
02097 inline Real norm_frobenius(const BaseMatrix& B) { return B.norm_Frobenius(); }
02098 inline Real NormFrobenius(const BaseMatrix& B) { return B.norm_Frobenius(); }
02099 inline Real trace(const BaseMatrix& B) { return B.trace(); }
02100 inline Real Trace(const BaseMatrix& B) { return B.trace(); }
02101 inline Real sum_absolute_value(const BaseMatrix& B)
02102 { return B.sum_absolute_value(); }
02103 inline Real SumAbsoluteValue(const BaseMatrix& B)
02104 { return B.sum_absolute_value(); }
02105 inline Real sum(const BaseMatrix& B)
02106 { return B.sum(); }
02107 inline Real Sum(const BaseMatrix& B)
02108 { return B.sum(); }
02109 inline Real maximum_absolute_value(const BaseMatrix& B)
02110 { return B.maximum_absolute_value(); }
02111 inline Real MaximumAbsoluteValue(const BaseMatrix& B)
02112 { return B.maximum_absolute_value(); }
02113 inline Real minimum_absolute_value(const BaseMatrix& B)
02114 { return B.minimum_absolute_value(); }
02115 inline Real MinimumAbsoluteValue(const BaseMatrix& B)
02116 { return B.minimum_absolute_value(); }
02117 inline Real maximum(const BaseMatrix& B) { return B.maximum(); }
02118 inline Real Maximum(const BaseMatrix& B) { return B.maximum(); }
02119 inline Real minimum(const BaseMatrix& B) { return B.minimum(); }
02120 inline Real Minimum(const BaseMatrix& B) { return B.minimum(); }
02121 inline Real norm1(const BaseMatrix& B) { return B.norm1(); }
02122 inline Real Norm1(const BaseMatrix& B) { return B.norm1(); }
02123 inline Real norm1(RowVector& RV) { return RV.maximum_absolute_value(); }
02124 inline Real Norm1(RowVector& RV) { return RV.maximum_absolute_value(); }
02125 inline Real norm_infinity(const BaseMatrix& B) { return B.norm_infinity(); }
02126 inline Real NormInfinity(const BaseMatrix& B) { return B.norm_infinity(); }
02127 inline Real norm_infinity(ColumnVector& CV)
02128 { return CV.maximum_absolute_value(); }
02129 inline Real NormInfinity(ColumnVector& CV)
02130 { return CV.maximum_absolute_value(); }
02131 inline bool IsZero(const GeneralMatrix& A) { return A.IsZero(); }
02132 inline bool is_zero(const GeneralMatrix& A) { return A.is_zero(); }
02133
02134
02135 inline MatrixInput MatrixInput::operator<<(int f) { return *this << (Real)f; }
02136 inline MatrixInput GeneralMatrix::operator<<(int f) { return *this << (Real)f; }
02137 inline MatrixInput BandMatrix::operator<<(int f) { return *this << (Real)f; }
02138 inline MatrixInput GetSubMatrix::operator<<(int f) { return *this << (Real)f; }
02139
02140 inline ReversedMatrix BaseMatrix::Reverse() const { return reverse(); }
02141 inline RowedMatrix BaseMatrix::AsRow() const { return as_row(); }
02142 inline ColedMatrix BaseMatrix::AsColumn() const { return as_column(); }
02143 inline DiagedMatrix BaseMatrix::AsDiagonal() const { return as_diagonal(); }
02144 inline MatedMatrix BaseMatrix::AsMatrix(int m, int n) const
02145 { return as_matrix(m, n); }
02146 inline GetSubMatrix BaseMatrix::SubMatrix(int fr, int lr, int fc, int lc) const
02147 { return submatrix(fr, lr, fc, lc); }
02148 inline GetSubMatrix BaseMatrix::SymSubMatrix(int f, int l) const
02149 { return sym_submatrix(f, l); }
02150 inline GetSubMatrix BaseMatrix::Row(int f) const { return row(f); }
02151 inline GetSubMatrix BaseMatrix::Rows(int f, int l) const { return rows(f, l); }
02152 inline GetSubMatrix BaseMatrix::Column(int f) const { return column(f); }
02153 inline GetSubMatrix BaseMatrix::Columns(int f, int l) const
02154 { return columns(f, l); }
02155 inline Real BaseMatrix::AsScalar() const { return as_scalar(); }
02156
02157 inline ReturnMatrix GeneralMatrix::ForReturn() const { return for_return(); }
02158
02159 inline void swap(Matrix& A, Matrix& B) { A.swap(B); }
02160 inline void swap(SquareMatrix& A, SquareMatrix& B) { A.swap(B); }
02161 inline void swap(nricMatrix& A, nricMatrix& B) { A.swap(B); }
02162 inline void swap(UpperTriangularMatrix& A, UpperTriangularMatrix& B)
02163 { A.swap(B); }
02164 inline void swap(LowerTriangularMatrix& A, LowerTriangularMatrix& B)
02165 { A.swap(B); }
02166 inline void swap(SymmetricMatrix& A, SymmetricMatrix& B) { A.swap(B); }
02167 inline void swap(DiagonalMatrix& A, DiagonalMatrix& B) { A.swap(B); }
02168 inline void swap(RowVector& A, RowVector& B) { A.swap(B); }
02169 inline void swap(ColumnVector& A, ColumnVector& B) { A.swap(B); }
02170 inline void swap(CroutMatrix& A, CroutMatrix& B) { A.swap(B); }
02171 inline void swap(BandMatrix& A, BandMatrix& B) { A.swap(B); }
02172 inline void swap(UpperBandMatrix& A, UpperBandMatrix& B) { A.swap(B); }
02173 inline void swap(LowerBandMatrix& A, LowerBandMatrix& B) { A.swap(B); }
02174 inline void swap(SymmetricBandMatrix& A, SymmetricBandMatrix& B) { A.swap(B); }
02175 inline void swap(BandLUMatrix& A, BandLUMatrix& B) { A.swap(B); }
02176 inline void swap(IdentityMatrix& A, IdentityMatrix& B) { A.swap(B); }
02177 inline void swap(GenericMatrix& A, GenericMatrix& B) { A.swap(B); }
02178
02179 #ifdef OPT_COMPATIBLE // for compatibility with opt++
02180
02181 inline Real Norm2(const ColumnVector& CV) { return CV.norm_Frobenius(); }
02182 inline Real Dot(ColumnVector& CV1, ColumnVector& CV2)
02183 { return dotproduct(CV1, CV2); }
02184
02185 #endif
02186
02187
02188 #ifdef use_namespace
02189 }
02190 #endif
02191
02192
02193 #endif
02194
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02210
02211
02212
02213