home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / incl / matrix.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  3.7 KB  |  159 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  matrix.h
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17.  
  18. //------------------------------------------------------------------------------
  19. //  matrices
  20. //
  21. //  Stefan Naeher (1988)
  22. //------------------------------------------------------------------------------
  23.  
  24. #ifndef MATRIXH
  25. #define MATRIXH
  26.  
  27. #ifndef MATRIX_DEFAULT_DIM1
  28. #define MATRIX_DEFAULT_DIM1 2
  29. #endif
  30.  
  31. #ifndef MATRIX_DEFAULT_DIM2
  32. #define MATRIX_DEFAULT_DIM2 2
  33. #endif
  34.  
  35.  
  36.  
  37. #include <LEDA/basic.h>
  38. #include <LEDA/vector.h>
  39.  
  40.  
  41.  
  42. struct matrix_rep {
  43.  
  44.    vector* v;
  45.    int  dim1;
  46.    int  dim2;
  47.  
  48.  matrix_rep(int, int);
  49.  matrix_rep(const matrix_rep*);
  50.  matrix_rep(int,int,double**);
  51.  
  52. ~matrix_rep();
  53.  
  54. OPERATOR_NEW(3)
  55. OPERATOR_DEL(3)
  56.  
  57. };
  58.  
  59.  
  60.  
  61. class matrix{
  62.  
  63.    matrix_rep* ptr;
  64.  
  65. void check_dimensions(const matrix&) const; 
  66.  
  67. void flip_rows(int i,int j)
  68. { vector_rep* p = ptr->v[i].ptr;
  69.   ptr->v[i].ptr = ptr->v[j].ptr;
  70.   ptr->v[j].ptr = p;
  71. }
  72.  
  73. double  elem(int i, int j) const { return ptr->v[i].ptr->v[j]; }
  74.  
  75. double** triang(const matrix&, int&) const;
  76.  
  77. public:
  78.  
  79.  
  80. matrix()  { ptr = new matrix_rep(MATRIX_DEFAULT_DIM1,MATRIX_DEFAULT_DIM2); }
  81.  
  82. matrix(int d1, int d2)             { ptr = new matrix_rep(d1,d2); }
  83. matrix(int d1, int d2, double** p) { ptr = new matrix_rep(d1,d2,p); }
  84. matrix(const matrix& mat) { ptr = new matrix_rep(mat.ptr); }
  85. matrix(void* p)           { ptr = new matrix_rep((matrix_rep*) p ); }
  86.  
  87. matrix(const vector&);
  88.  
  89. void clear() { delete ptr; }
  90.  
  91. ~matrix()    { clear(); } 
  92.  
  93. int     dim1()  const  {  return ptr->dim1; }
  94. int     dim2()  const  {  return ptr->dim2; }
  95.  
  96. vector& row(int) const;
  97. vector  col(int i) const;
  98. matrix  trans() const;
  99.  
  100. matrix  inv()   const;
  101. double  det()   const;
  102.  
  103. matrix solve(const matrix&) const;
  104. vector solve(const vector& b) const { return solve(matrix(b)); }
  105.  
  106. operator vector() const; 
  107.  
  108. matrix& operator=(const matrix&);
  109.  
  110. int     operator==(const matrix&)    const;
  111. int     operator!=(const matrix& x)  const { return !(*this == x); }
  112.  
  113. vector& operator[](int i)    const { return row(i); }
  114. double  operator()(int, int) const;
  115. double& operator()(int, int);
  116.  
  117. matrix operator+(const matrix&);
  118. matrix operator-(const matrix&);
  119.  
  120. matrix operator*(double);
  121. matrix operator*(const matrix&);
  122. vector operator*(const vector& v) { return vector(*this * matrix(v)); }
  123.  
  124. friend ostream& operator<<(ostream&, const matrix&);
  125. friend istream& operator>>(istream&, matrix&);
  126.  
  127. friend void Print(matrix& M, ostream& out=cout) { out << M; } 
  128. friend void Read(matrix& M, istream& in=cin)  { in >> M; }
  129.  
  130. friend void Clear(matrix& M)      { M.clear(); }
  131. friend ent  Copy(const matrix& M) { return new matrix_rep(M.ptr); }
  132. friend ent  Init(matrix& M)  { return new matrix_rep(M.ptr); }
  133. friend ent  Ent(matrix& M)   { return M.ptr; }
  134.  
  135. friend int  compare(matrix& x, matrix& y) { return int(x.ptr) - int(y.ptr); }
  136.  
  137. };
  138.  
  139.  
  140. //------------------------------------------------------------------------------
  141. // MATRIX(cmp): vector with user defined linear order cmp
  142. //------------------------------------------------------------------------------
  143.  
  144. #define MATRIX(cmp) name2(matrix_,cmp)
  145.  
  146. #define MATRIXdeclare(cmp)\
  147. struct MATRIX(cmp) : public matrix \
  148. {  MATRIX(cmp)(ent p)          :(p)     {}\
  149.    MATRIX(cmp)(int d1, int d2) :(d1,d2) {}\
  150.    MATRIX(cmp)(matrix  m )     :(m)     {}\
  151.    MATRIX(cmp)(MATRIX(cmp)& m) :(m)     {}\
  152.    MATRIX(cmp)() {}\
  153.  ~ MATRIX(cmp)() {}\
  154. };\
  155. \
  156. int compare(MATRIX(cmp)& x, MATRIX(cmp)& y) { return cmp(x,y); }
  157.  
  158. #endif
  159.