00001
00002
00003
00004
00005 #ifndef VECOP_H
00006 #define VECOP_H
00007
00008
00009
00010 #include <iostream>
00011 #include <vector>
00012 #include <functional>
00013 #include <numeric>
00014
00015
00016
00017
00018
00019 template<class T> std::vector<T> operator+(const std::vector<T>& v1, const std::vector<T>& v2)
00020 {
00021 std::vector<T> tmp = v1;
00022 std::transform(tmp.begin(), tmp.end(), v2.begin(), tmp.begin(), std::plus<T>());
00023 return tmp;
00024 }
00025
00026 template<class T> std::vector<T> operator-(const std::vector<T>& v1, const std::vector<T>& v2)
00027 {
00028 std::vector<T> tmp = v1;
00029 std::transform(tmp.begin(), tmp.end(), v2.begin(), tmp.begin(), std::minus<T>());
00030 return tmp;
00031 }
00032
00033 template<class T> T operator*(const std::vector<T>& v1, const std::vector<T>& v2)
00034 {
00035 return inner_product(v1.begin(), v1.end(), v2.begin(), static_cast<T>(0));
00036 }
00037
00038 template<class T> T operator/(const std::vector<T>& v1, const std::vector<T>& v2)
00039 {
00040 return inner_product(v1.begin(), v1.end(), v2.begin(), static_cast<T>(0),
00041 std::plus<T>(), std::divides<T>());
00042 }
00043
00044
00045
00046
00047
00048 template<class T> std::vector<T>& operator+=(std::vector<T>& v1, const std::vector<T>& v2)
00049 {
00050 std::transform(v1.begin(), v1.end(), v2.begin(), v1.begin(), std::plus<T>());
00051 return v1;
00052 }
00053
00054 template<class T> std::vector<T>& operator-=(std::vector<T>& v1, const std::vector<T>& v2)
00055 {
00056 std::transform(v1.begin(), v1.end(), v2.begin(), v1.begin(), std::minus<T>());
00057 return v1;
00058 }
00059
00060
00061
00062
00063
00064 template<class A, class B> std::vector<A> operator+(const std::vector<A>& a, const B& b)
00065 {
00066 std::vector<A> tmp = a;
00067 std::transform(tmp.begin(), tmp.end(), tmp.begin(), std::bind2nd(std::plus<A>(), b));
00068 return tmp;
00069 }
00070
00071 template<class A, class B> std::vector<A> operator-(const std::vector<A>& a, const B& b)
00072 {
00073 std::vector<A> tmp = a;
00074 std::transform(tmp.begin(), tmp.end(), tmp.begin(), std::bind2nd(std::minus<A>(), b));
00075 return tmp;
00076 }
00077
00078 template<class A, class B> std::vector<A> operator*(const std::vector<A>& a, const B& b)
00079 {
00080 std::vector<A> tmp = a;
00081 std::transform(tmp.begin(), tmp.end(), tmp.begin(), std::bind2nd(std::multiplies<A>(), b));
00082 return tmp;
00083 }
00084
00085 template<class A, class B> std::vector<A> operator/(const std::vector<A>& a, const B& b)
00086 {
00087 std::vector<A> tmp = a;
00088 std::transform(tmp.begin(), tmp.end(), tmp.begin(), std::bind2nd(std::divides<A>(), b));
00089 return tmp;
00090 }
00091
00092
00093
00094
00095
00096 template<class A, class B> std::vector<A> operator+(const B& b, const std::vector<A>& a)
00097 {
00098 std::vector<A> tmp = a;
00099 std::transform(tmp.begin(), tmp.end(), tmp.begin(), std::bind2nd(std::plus<A>(), b));
00100 return tmp;
00101 }
00102
00103 template<class A, class B> std::vector<A> operator-(const B& b, const std::vector<A>& a)
00104 {
00105 std::vector<A> tmp(a.size(), b);
00106 std::transform(tmp.begin(), tmp.end(), a.begin(), tmp.begin(), std::minus<A>());
00107 return tmp;
00108 }
00109
00110 template<class A, class B> std::vector<A> operator*(const B& b, const std::vector<A>& a)
00111 {
00112 std::vector<A> tmp = a;
00113 std::transform(tmp.begin(), tmp.end(), tmp.begin(), bind2nd(std::multiplies<A>(), b));
00114 return tmp;
00115 }
00116
00117 template<class A, class B> std::vector<A> operator/(const B& b, const std::vector<A>& a)
00118 {
00119 std::vector<A> tmp(a.size(), b);
00120 std::transform(tmp.begin(), tmp.end(), a.begin(), tmp.begin(), std::divides<A>());
00121 return tmp;
00122 }
00123
00124
00125
00126
00127
00128 template<class A, class B> std::vector<A>& operator+=(std::vector<A>& a, const B& b)
00129 {
00130 std::transform(a.begin(), a.end(), a.begin(), std::bind2nd(std::plus<A>(), b));
00131 return a;
00132 }
00133
00134 template<class A, class B> std::vector<A>& operator-=(std::vector<A>& a, const B& b)
00135 {
00136 std::transform(a.begin(), a.end(), a.begin(), std::bind2nd(std::minus<A>(), b));
00137 return a;
00138 }
00139
00140 template<class A, class B> std::vector<A>& operator*=(std::vector<A>& a, const B& b)
00141 {
00142 std::transform(a.begin(), a.end(), a.begin(), std::bind2nd(std::multiplies<A>(), b));
00143 return a;
00144 }
00145
00146 template<class A, class B> std::vector<A>& operator/=(std::vector<A>& a, const B& b)
00147 {
00148 std::transform(a.begin(), a.end(), a.begin(), std::bind2nd(std::divides<A>(), b));
00149 return a;
00150 }
00151
00152
00153
00154
00155
00156 template<class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
00157 {
00158 os << '<';
00159 if (v.size())
00160 {
00161 std::copy(v.begin(), v.end() - 1, std::ostream_iterator<T>(os, " "));
00162 os << v.back();
00163 }
00164 return os << '>';
00165 }
00166
00167 template<class T> std::istream& operator>>(std::istream& is, std::vector<T>& v)
00168 {
00169 v.clear();
00170
00171 char c;
00172 is >> c;
00173 if (!is || c != '<')
00174 is.setstate(std::ios::failbit);
00175 else
00176 {
00177 T t;
00178 do {
00179 is >> c;
00180 if (is && c!= '>')
00181 {
00182 is.putback(c);
00183 is >> t;
00184 if (is)
00185 v.push_back(t);
00186 }
00187 } while (is && c != '>');
00188 }
00189
00190 return is;
00191 }
00192
00193 //-----------------------------------------------------------------------------
00194 // euclidean_distance
00195 //-----------------------------------------------------------------------------
00196
00197 template<class T> T euclidean_distance(const std::vector<T>& v1,
00198 const std::vector<T>& v2)
00199 {
00200 T sum = 0, tmp;
00201
00202 for (unsigned i = 0; i < v1.size(); ++i)
00203 {
00204 tmp = v1[i] - v2[i];
00205 sum += tmp * tmp;
00206 }
00207
00208 return sqrt(sum);
00209 }
00210
00211 //-----------------------------------------------------------------------------
00212
00213 #endif
00214