home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / basic / _vector.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  3.4 KB  |  174 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _vector.c
  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. /*  Vektoren und Matrizen */
  18.  
  19. #include <LEDA/vector.h> 
  20. #include <math.h>
  21.  
  22. vector_rep::vector_rep(int d) 
  23. { 
  24.  if (d<0) error_handler(1,"vector: negative dimension."); 
  25.  
  26.  dim = d; 
  27.  
  28.  if (d>0)
  29.  { v   = new double[dim];
  30.    while (d--) v[d] = 0.0;
  31.   }
  32.  else v = nil;
  33.  
  34.  }
  35.  
  36. vector_rep::vector_rep(vector_rep* p) 
  37. {
  38.   int n = p->dim;
  39.   dim = n; 
  40.  
  41.   if (n>0)
  42.   { v   = new double[n];
  43.     while (n--) v[n] = p->v[n];
  44.    }
  45.   else v = nil;
  46.  }
  47.  
  48.  
  49. void vector::check_dimensions(const vector& vec) const
  50. { if (dim()!=vec.dim() )
  51.    error_handler(1,"vector arguments have different dimensions.");
  52.  }
  53.  
  54.  
  55.  
  56. vector::vector(double x, double y) 
  57. { ptr = new vector_rep(2); 
  58.   ptr->v[0] = x;
  59.   ptr->v[1] = y;
  60.  }
  61.  
  62. vector::vector(double x, double y, double z) 
  63. { ptr = new vector_rep(3); 
  64.   ptr->v[0] = x;
  65.   ptr->v[1] = y;
  66.   ptr->v[2] = z;
  67.  }
  68.  
  69. double  vector::operator[](int i) const
  70. { if (i<0 || i>=dim())  error_handler(1,"vector: index out of range ");
  71.   return ptr->v[i]; 
  72. }
  73.  
  74. double& vector::operator[](int i)
  75. { if (i<0 || i>=dim())  error_handler(1,"vector: index out of range ");
  76.   return ptr->v[i]; 
  77. }
  78.  
  79. vector vector::operator+(const vector& vec) const
  80. { check_dimensions(vec);
  81.   register int n = dim();
  82.   vector result(n);
  83.   while (n--) result.ptr->v[n] = ptr->v[n]+vec.ptr->v[n];
  84.   return result;
  85. }
  86.  
  87. vector vector::operator-(const vector& vec) const
  88. { check_dimensions(vec);
  89.   register int n = dim();
  90.   vector result(n);
  91.   while (n--) result.ptr->v[n] = ptr->v[n]-vec.ptr->v[n];
  92.   return result;
  93. }
  94.  
  95.  
  96. vector vector::operator*(double d) const
  97. { int n = dim();
  98.   vector result(n);
  99.   while (n--) result.ptr->v[n] = ptr->v[n] * d;
  100.   return result;
  101. }
  102.  
  103. vector vector::operator/(double d) const
  104. { int n = dim();
  105.   vector result(n);
  106.   while (n--) result.ptr->v[n] = ptr->v[n] / d;
  107.   return result;
  108. }
  109.  
  110. //friend
  111. vector operator*(double f, const vector& v) { return v*f;     } 
  112.  
  113. double vector::operator*(const vector& vec) const
  114. { check_dimensions(vec);
  115.   double result=0;
  116.   register int n = dim();
  117.   while (n--) result = result+ptr->v[n]*vec.ptr->v[n];
  118.   return result;
  119. }
  120.  
  121. vector::vector(const vector& vec)
  122. { register int n = vec.dim();
  123.   ptr = new vector_rep(n);
  124.   while (n--) ptr->v[n] = vec.ptr->v[n];
  125. }
  126.   
  127. vector& vector::operator=(const vector& vec)
  128. { register int d = vec.dim();
  129.   if (d!=dim())
  130.   { clear();
  131.     ptr = new vector_rep(d);
  132.    }
  133.   while (d--) ptr->v[d] = vec.ptr->v[d];
  134.   return *this;
  135. }
  136.  
  137.  
  138. int vector::operator==(const vector& vec)  const
  139. { if (vec.dim() != dim()) return false;
  140.   int i = 0;
  141.   int d = dim();
  142.   while ((i<d) && (ptr->v[i]==vec.ptr->v[i])) i++;
  143.   return (i==d) ? true : false;
  144.  }
  145.  
  146.  
  147. ostream& operator<<(ostream& s, const vector& v)
  148. { int i;
  149.   char buf[16];
  150.   for (i=0;i<v.dim();i++) 
  151.   { sprintf(buf,"%7.2f ",v[i]);
  152.     s << buf;
  153.    }
  154.   return s;
  155. }
  156.  
  157. istream& operator>>(istream& s, vector& v)
  158. { int i=0;
  159.   while (i<v.dim() && s >> v.ptr->v[i++]);
  160.   return s;
  161. }
  162.  
  163. double vector::length() const { return sqrt(*this * *this); }
  164.  
  165. double vector::angle(const vector& y)  const
  166. { double l = length();
  167.   double yl = y.length();
  168.  
  169.   if ( l==0 || yl==0)
  170.    error_handler(1,"angle: zero argument\n");
  171.  
  172.   return  acos((*this)*y/(l*yl));  
  173. }
  174.