home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / incl / vector.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  3.7 KB  |  153 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  vector.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. //  vectors and matrices
  20. //
  21. //  Stefan Naeher (1988)
  22. //------------------------------------------------------------------------------
  23.  
  24. #ifndef VECTOR_REPH
  25. #define VECTOR_REPH
  26.  
  27. #include <LEDA/basic.h>
  28.  
  29. #ifndef VEC_DEFAULT_DIM
  30. #define VEC_DEFAULT_DIM 2
  31. #endif
  32.  
  33.  
  34. struct vector_rep{
  35.  
  36.    double* v;
  37.    int dim;
  38.  
  39. public:
  40.  
  41.  vector_rep(int); 
  42.  vector_rep(vector_rep*); 
  43.  
  44. ~vector_rep() { if (v) delete v; }
  45.  
  46. OPERATOR_NEW(2)
  47. OPERATOR_DEL(2)
  48.  
  49. };
  50.  
  51.  
  52. class vector{
  53.  
  54. friend class matrix_rep;
  55. friend class matrix;
  56.  
  57. vector_rep* ptr;
  58.  
  59. void check_dimensions(const vector&) const;
  60.  
  61. public:
  62.  
  63.  
  64. vector()      { ptr = new vector_rep(VEC_DEFAULT_DIM); }
  65. vector(int d) { ptr = new vector_rep(d);               }
  66.  
  67. vector(double, double);
  68. vector(double, double, double);
  69. vector(const vector&);
  70.  
  71. vector(void* p)  { ptr = new vector_rep((vector_rep*)p); }
  72.  
  73. void clear()     { delete ptr; }
  74.  
  75. ~vector()        { clear(); }
  76.  
  77.  
  78.  
  79. double length() const;
  80.  
  81. int    dim()    const { return ptr->dim; }
  82. vector norm()   const { return *this/length(); }
  83.  
  84. double angle(const vector&) const; 
  85.  
  86. vector& operator=(const vector&);
  87.  
  88. double& operator[](int);
  89.  
  90. double  operator[](int) const;
  91.  
  92. vector  operator+(const vector&) const;
  93. vector  operator-(const vector&) const;
  94. vector  operator*(double)        const;
  95. vector  operator/(double)        const;
  96. double  operator*(const vector&) const;
  97.  
  98. int     operator==(const vector&) const;
  99. int     operator!=(const vector& w)  const { return !(*this == w); }
  100.  
  101. /*
  102. friend vector operator*(double f, const vector& v);
  103. friend vector operator/(const vector& v, double f)}
  104.  
  105. omitted, because of error in cfront's type conversion algorithm
  106.  
  107. otherwise  (real) * (double f) is ambiguous a) ---> (double) * (double)
  108.                                             b) ---> (double) * (vector)
  109.  
  110. and        (double f) / (real) is ambiguous a) ---> (double) * (double)
  111.                                             b) ---> (vector) * (double)
  112.  
  113. Unbelievable, but true: if f is an inline function returning a double 
  114. it may be converted to a vector using the "vector(int)" constructor!!!
  115. */
  116.  
  117.  
  118. friend ostream& operator<<(ostream& o, const vector& v);
  119. friend istream& operator>>(istream& i, vector& v);
  120.  
  121. friend void Print(vector& v, ostream& out=cout) { out << v; } 
  122. friend void Read(vector& v, istream& in=cin)  { in >> v; }
  123.  
  124. friend void Clear(vector& v)       { v.clear(); }
  125. friend ent  Copy(const vector& v)  { return ent(new vector_rep(v.ptr)); }
  126. friend ent  Init(vector& v)  { return ent(new vector_rep(v.ptr)); }
  127. friend ent  Ent(vector& v)   { return ent(v.ptr); }
  128.  
  129. friend int  compare(vector& x, vector& y) { return int(x.ptr) - int(y.ptr); }
  130.  
  131. };
  132.  
  133.  
  134. //------------------------------------------------------------------------------
  135. // VECTOR(cmp): vector with user defined linear order cmp
  136. //------------------------------------------------------------------------------
  137.  
  138. #define VECTOR(cmp) name2(vector_,cmp)
  139.  
  140. #define VECTORdeclare(cmp)\
  141. struct VECTOR(cmp) : public vector \
  142. {  VECTOR(cmp)(ent p)          :vector(p) {}\
  143.    VECTOR(cmp)(double r)       :vector(r) {}\
  144.    VECTOR(cmp)(vector  r )     :vector(r) {}\
  145.    VECTOR(cmp)(const VECTOR(cmp)& r) :vector(r) {}\
  146.    VECTOR(cmp)() {}\
  147.  ~ VECTOR(cmp)() {}\
  148. };\
  149. \
  150. int compare(VECTOR(cmp)& x, VECTOR(cmp)& y) { return cmp(x,y); }
  151.  
  152. #endif
  153.