开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_vector.h
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：7k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_vector.h：源码内容
  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. *******************************************************************************/
  14. #ifndef LEDA_PAR_VECTOR_H
  15. #define LEDA_PAR_VECTOR_H
  17. //----------------------------------------------------------------------
  18. //  parameterized vectors:  _vector<T>
  19. //----------------------------------------------------------------------
  20. //
  21. // generic vectors with entries of type T
  22. // T must support the following operators and functions:
  23. //
  24. // T::operator+, T::operator-, T::operator*, T::operator/
  25. // T::operator+=, T::operator-=, T::operator*=, T::operator/=
  26. // T::operator=, T::operator==
  27. // T::operator<, T::operator>
  28. // T::operator<<, T::operator>>
  29. // sqrt(), acos()
  32. #include <LEDA/basic.h>
  33. #include <math.h>
  35. template<class T> class _vector
  36. {
  37.   T* v;
  38.   int d;
  40.   void check_dimensions(const _vector<T>&) const;
  41.  
  42. public:
  44.   _vector(); 
  45.   _vector(int); 
  46.   _vector(const T&, const T&);
  47.   _vector(const T&, const T&, const T&);
  48.   _vector(const _vector<T>&);
  50.   ~_vector();
  51.  
  53.   T length() const;
  54.   
  55.   int dim() const;
  56.   _vector<T> norm() const;
  57.   
  58.   T angle(const _vector<T>&) const; 
  59.   
  60.   _vector<T>& operator=(const _vector<T>&);
  61.   
  62.   T& operator[](int);
  63.   T operator[](int) const;
  64.   
  65.   _vector<T> operator+(const _vector<T>&) const;
  66.   _vector<T> operator-(const _vector<T>&) const;
  68.   _vector<T> operator*(const T&) const;
  69.   _vector<T> operator/(const T&) const;
  71.   T operator*(const _vector<T>&) const;
  73.   int operator==(const _vector<T>&) const;
  74.   int operator!=(const _vector<T>&) const;
  75.   
  76.   
  77.   friend _vector<T> operator-(const _vector<T>&);
  78.   
  79.   friend ostream& operator<<(ostream&, const _vector<T>&);
  80.   friend istream& operator>>(istream&, _vector<T>&);
  82.   friend int compare(const _vector<T>&, const _vector<T>&);
  83. };
  85. template<class T> void
  86. _vector<T>::check_dimensions(const _vector<T>& p) const
  87. { if (d != p.d) error_handler(1,"_vector: _vector arguments have different dimensions"); };
  89. template<class T>
  90. _vector<T>::_vector()
  91. { d = 0; v = nil; };
  93. template<class T>
  94. _vector<T>::_vector(int n)
  95. {
  96.   if (n < 0) error_handler(1,"_vector: negative dimension!");
  97.   d = n;
  98.   if (d > 0) {
  99.     v = new T[d];
  100.     T* pv = v + d;
  101.     while (n--) { *--pv = 0; }
  102.   }
  103.   else { v = nil; }
  104. };
  106. template<class T>
  107. _vector<T>::_vector(const T& x, const T& y)
  108. {
  109.   d = 2;
  110.   v = new T[d];
  111.   v[0] = x;
  112.   v[1] = y;
  113. };
  115. template<class T>
  116. _vector<T>::_vector(const T& x, const T& y, const T& z)
  117. {
  118.   d = 3;
  119.   v = new T[d];
  120.   v[0] = x;
  121.   v[1] = y;
  122.   v[2] = z;
  123. };
  125. template<class T>
  126. _vector<T>::_vector(const _vector<T>& p)
  127. {
  128.   d = p.d;
  129.   if (d > 0) {
  130.     v = new T[d];
  131.     register int stop = d;
  132.     register T* pv = v + d;
  133.     register T* pp = p.v + d;
  134.     while (stop--) *--pv = *--pp;
  135.   }
  136.   else v = nil;
  137. };
  139. template<class T>
  140. _vector<T>::~_vector()
  141. { if (v) delete v; };
  143. template<class T> T
  144. _vector<T>::length() const
  145. { return sqrt((*this) * (*this)); };
  147. int
  148. _vector<int>::length() const
  149. { error_handler(1,"_vector<int>: length not implemented"); return 0; };
  151. template<class T> int
  152. _vector<T>::dim() const
  153. { return d; };
  155. template<class T> _vector<T>
  156. _vector<T>::norm() const
  157. { return (*this)/length(); };
  159. _vector<int>
  160. _vector<int>::norm() const
  161. {
  162.   error_handler(1,"_vector<int>: norm not implemented");
  163.   _vector<int> v;
  164.   return v;
  165. };
  167. template<class T> T
  168. _vector<T>::angle(const _vector<T>& p) const 
  169. {
  170.   T lv = length();
  171.   T lp = p.length();
  172.   if ((lv == 0) || (lp == 0)) {
  173.     error_handler(1,"_vector: zero length _vector");
  174.   }
  175.   return acos(((*this) * p) / (lv * lp));
  176. };
  179. int _vector<int>::angle(const _vector<int>&) const
  180. { error_handler(1,"_vector<int>: angle not implemented"); return 0; };
  183. template<class T> _vector<T>&
  184. _vector<T>::operator=(const _vector<T>& p)
  185. {
  186.   register int n = p.d;
  187.   if (d != n) {
  188.     delete v;
  189.     d = n;
  190.     v = new T[d];
  191.   }
  192.   register T* pv = v + d;
  193.   register T* pp = p.v + d;
  194.   while (n--) { *--pv = *--pp; }
  195.   return (*this);
  196. };
  198. template<class T> T&
  199. _vector<T>::operator[](int i)
  200. {
  201.   if ((i < 0) || (i >= d)) {
  202.     error_handler(1,"_vector: index out of range");
  203.   }
  204.   return v[i]; 
  205. };
  207. template<class T> T
  208. _vector<T>::operator[](int i) const
  209. {
  210.   if ((i < 0) || (i >= d)) {
  211.     error_handler(1,"_vector: index out of range");
  212.   }
  213.   return v[i]; 
  214. };
  216. template<class T> _vector<T>
  217. _vector<T>::operator+(const _vector<T>& p) const
  218. {
  219.   check_dimensions(p);
  220.   register int n = d;
  221.   _vector<T> result(*this);
  222.   register T* pr = result.v + d;
  223.   register T* pp = p.v + d;
  224.   while (n--) { *--pr += *--pp; }
  225.   return result;
  226. };
  228. template<class T> _vector<T>
  229. _vector<T>::operator-(const _vector<T>& q) const
  230. {
  231.   check_dimensions(q);
  232.   _vector<T> result(*this);
  233.   register int n = result.d;
  234.   register T* pr = result.v + n;
  235.   register T* pq = q.v + q.d;
  236.   while (n--) { *--pr -= *--pq; }
  237.   return result;
  238. };
  240. template<class T> _vector<T>
  241. _vector<T>::operator*(const T& s) const
  242. {
  243.   register int n = d;
  244.   _vector<T> result(*this);
  245.   register T* pr = result.v + d;
  246.   while (n--) { *--pr *= s; }
  247.   return result;
  248. };
  250. template<class T> _vector<T>
  251. operator*(const T& s, const _vector<T>& p)
  252. { return p*s; };
  254. template<class T> _vector<T>
  255. _vector<T>::operator/(const T& s) const
  256. {
  257.   if (s == 0) error_handler(1,"_vector: division by 0");
  258.   register int n = d;
  259.   _vector<T> result(*this);
  260.   register T* pr = result.v + d;
  261.   while (n--) { *--pr /= s; }
  262.   return result;
  263. };
  265. template<class T> T
  266. _vector<T>::operator*(const _vector<T>& p) const
  267. {
  268.   check_dimensions(p);
  269.   register int n = d;
  270.   T result = 0;
  271.   register T* pv = v + d;
  272.   register T* pp = p.v + d;
  273.   while (n--) result += ((*--pv) * (*--pp));
  274.   return result;
  275. };
  276.   
  277. template<class T> int
  278. _vector<T>::operator==(const _vector<T>& p) const
  279. {
  280.   if (p.d != d) return false;
  281.   register int i = d;
  282.   register T* pv = v + d;
  283.   register T* pp = p.v + d;
  284.   while ((i) && ((*--pv) == (*--pp))) i--;
  285.   return (!i);
  286. };
  288. template<class T> int
  289. _vector<T>::operator!=(const _vector<T>& w) const
  290. { return !(*this == w); };
  292. template<class T> _vector<T>
  293. operator-(const _vector<T>& p)
  294. {
  295.   _vector<T> zerovec(p.d); // initialized with zeros
  296.   return zerovec - p;
  297. };
  299. template<class T> ostream&
  300. operator<<(ostream& out, const _vector<T>& p)
  301. {
  302.   register int i;
  303.   for (i = 0; i < p.d; i++) {
  304.     out << p.v[i] << " ";
  305.   }
  306.   return out;
  307. }
  309. template<class T> istream&
  310. operator>>(istream& in, _vector<T>& p)
  311. { int i=0;
  312.   while (i < p.d && in >> p.v[i++]);
  313.   return in;
  314. }
  316. template<class T> int
  317. compare(const _vector<T>& v1, const _vector<T>& v2)
  318. { v1.check_dimensions(v2);
  319.   register T* pv1 = v1.v;
  320.   register T* pv2 = v2.v;
  321.   register T* stopv1 = v1.v + v1.d;
  322.   while ((pv1 < stopv1) && ((*pv1) == (*pv2))) { *pv1++; *pv2++; };
  323.   if (pv1 == stopv1) return 0;
  324.   else return (*pv1 < *pv2) ? -1 : 1;
  325. }
  327. template<class T> void
  328. Print(const _vector<T>& v, ostream& out)
  329. { out << v; };
  331. template<class T> void
  332. Read(_vector<T>& v, istream& in)
  333. { in >> v;  };
  335. #endif