Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
vector.h
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 4k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

vector.h：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  vector.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #ifndef LEDA_VECTOR_H
  14. #define LEDA_VECTOR_H
  16. //------------------------------------------------------------------------------
  17. //  vectors
  18. //------------------------------------------------------------------------------
  20. #include <LEDA/basic.h>
  23. /*{Manpage {vector} {} {Real-Valued Vectors}}*/
  25. class vector
  26. {
  28. /*{Mdefinition
  29. An instance of the data type $vector$ is a vector of real variables.}*/
  31.   friend class matrix;
  33.   double* v;
  34.   int d;
  36.   void check_dimensions(const vector&) const;
  37.  
  38. public:
  40. /*{Mcreation v }*/
  42. vector(); 
  43. /*{Mcreate creates an instance $v$ of type $vector$; $v$ is initialized to 
  44.             the zero-dimensional vector.}*/
  46. vector(int d); 
  47. /*{Mcreate creates an instance $v$ of type $vector$; $v$ is initialized to 
  48.             the zero vector of dimension $d$.}*/ 
  50. vector(double a, double b);
  51. /*{Mcreate creates an instance $v$ of type $vector$; $v$ is initialized to 
  52.             the two-dimensional vector $(a,b)$.}*/
  54. vector(double a, double b, double c);
  55. /*{Mcreate creates an instance $v$ of type $vector$; $v$ is initialized to 
  56.             the three-dimensional vector $(a,b,c)$.}*/
  58.   vector(const vector&);
  59.  ~vector(); 
  60.   vector& operator=(const vector&);
  63. /*{Moperations 2 4.5}*/
  65. int    dim()    const { return d; }
  66. /*{Mop       returns the dimension of $v$.}*/ 
  68. double length() const;
  69. /*{Mop      returns the Euclidean length of $v$.}*/
  70.   
  71. vector norm()   const { return *this/length(); }
  72.   
  73. double angle(const vector& w) const; 
  74. /*{Mop     returns the angle between $v$ and $w$.}*/
  76.   
  77. double& operator[](int i);
  78. /*{Marrop     returns $i$-th component of $v$.\
  79.        precond $0le i le v$.dim()$-$1.}*/
  80.   
  81. double  operator[](int) const;
  83. vector& operator+=(const vector&);
  84. vector& operator-=(const vector&);
  85.   
  86. vector  operator+(const vector& v1) const;
  87. /*{Mbinop     Addition.\
  88.        precond $v$.dim() = $v1$.dim().}*/
  90. vector  operator-(const vector& v1) const;
  91. /*{Mbinop     Subtraction.\
  92.        precond $v$.dim() = $v1$.dim().}*/
  94. double  operator*(const vector& v1) const;
  95. /*{Mbinop     Scalar multiplication.\
  96.                precond $v$.dim() = $v1$.dim().}*/
  98. vector  operator*(double r)        const;
  99. /*{Mbinop     Componentwise multiplication with double $r$.}*/
  101. vector  operator-() const;
  102. vector  operator/(double)        const;
  103.   
  104. bool     operator==(const vector& w) const;
  105. /*{Mbinop     Test for equality.}*/
  107. bool     operator!=(const vector& w)  const { return !(*this == w); }
  108. /*{Mbinop     Test for inequality.}*/
  110.   
  111. /*
  112. friend vector operator*(double f, const vector& v);
  113. friend vector operator/(const vector& v, double f);
  114. */
  115.   
  116. friend ostream& operator<<(ostream& O, const vector& v);
  117. /*{Mbinopfunc  writes $v$ componentwise to the output stream $O$.}*/
  119. friend istream& operator>>(istream& I, vector& v);
  120. /*{Mbinopfunc  reads $v$ componentwise from the input stream $I$.}*/
  122. static int cmp(const vector&, const vector&);
  123.  
  124. LEDA_MEMORY(vector)
  126. };
  128. inline int compare(const vector& x, const vector& y)
  129. { return vector::cmp(x,y); }
  132. inline void Print(const vector& v, ostream& out) 
  133. { out << v.dim() << " " << v; }
  135. inline void Read(vector& v, istream& in)         
  136. { int d;
  137.   in >> d;  
  138.   vector x(d);
  139.   in >> x;
  140.   v = x;
  141. }
  143. LEDA_TYPE_PARAMETER(vector)
  145. /*{Mimplementation
  146. Vectors are implemented by arrays of real numbers. All operations on a vector 
  147. $v$ take time $O(v.dim())$, except for dim and $[ ]$ which take constant
  148. time. The space requirement is $O(v.dim())$.
  149. }*/
  152. #endif