1 #include "VectorOperations.hpp"
2 #include <math.h>
3 #include <cassert>
4 #include <iostream>
5
6 //--------------------------------------------------------------------------------
set_zero(std::vector<double> & v)7 void VectorOperations::set_zero( std::vector<double> &v )
8 {
9 // computes v = 0;
10 size = v.size();
11 for ( int i = 0; i < size; ++i )
12 v[i] = 0e0;
13 return;
14 }
15 //--------------------------------------------------------------------------------
16
17 //--------------------------------------------------------------------------------
scale(double s,std::vector<double> const & v,std::vector<double> & w)18 void VectorOperations::scale(double s, std::vector<double> const& v,
19 std::vector<double> &w )
20 {
21 // computes w = s*v;
22 size = w.size();
23 for ( int i = 0; i < size; ++i )
24 w[i] = s * v[i];
25 return;
26 }
27 //--------------------------------------------------------------------------------
28
29 //--------------------------------------------------------------------------------
scale(double s,std::vector<std::vector<double>> const & V,std::vector<std::vector<double>> & W)30 void VectorOperations::scale(double s, std::vector< std::vector<double> > const& V,
31 std::vector< std::vector<double> > &W )
32 {
33 // computes W = s*V;
34 assert( W[0].size() == W.size() );
35 size = W[0].size();
36 for ( int i = 0; i < size; ++i ) {
37 for ( int j = 0; j < size; ++j )
38 W[i][j] = s * V[i][j];
39 }
40 return;
41 }
42 //--------------------------------------------------------------------------------
43
44 //--------------------------------------------------------------------------------
add(double s,std::vector<double> const & v,std::vector<double> & w)45 void VectorOperations::add( double s, std::vector<double> const &v,
46 std::vector<double> &w)
47 {
48 // computes w = w + s*v
49 size = w.size();
50 for ( int i = 0; i < size; i++)
51 w[i] += s * v[i];
52 return;
53 }
54 //--------------------------------------------------------------------------------
55
56 //--------------------------------------------------------------------------------
add(std::vector<double> const & v,std::vector<double> & w)57 void VectorOperations::add( std::vector<double> const &v,
58 std::vector<double> &w)
59 {
60 // computes w = w + v
61 size = w.size();
62 for ( int i = 0; i < size; i++)
63 w[i] += v[i];
64 return;
65 }
66 //--------------------------------------------------------------------------------
67
68 //--------------------------------------------------------------------------------
add(double s,std::vector<std::vector<double>> const & V,std::vector<std::vector<double>> & W)69 void VectorOperations::add( double s, std::vector< std::vector<double> > const &V,
70 std::vector< std::vector<double> > &W)
71 {
72 // computes W = W + s*V
73 assert( W[0].size() == W.size() );
74 size = W[0].size();
75 for ( int i = 0; i < size; i++) {
76 for ( int j = 0; j < size; j++)
77 W[i][j] += s * V[i][j];
78 }
79 return;
80 }
81 //--------------------------------------------------------------------------------
82
83 //--------------------------------------------------------------------------------
minus(std::vector<double> const & v1,std::vector<double> const & v2,std::vector<double> & w)84 void VectorOperations::minus(std::vector<double> const& v1,
85 std::vector<double> const& v2,
86 std::vector<double> &w )
87 {
88 // computes w = v1 - v2;
89 for ( unsigned int i = 0; i < w.size(); ++i )
90 w[i] = ( v1[i] - v2[i] );
91 return;
92 }
93 //--------------------------------------------------------------------------------
94
95 //--------------------------------------------------------------------------------
rescale(double s,std::vector<double> const & v1,std::vector<double> const & v2,std::vector<double> & w)96 void VectorOperations::rescale(double s, std::vector<double> const& v1,
97 std::vector<double> const& v2,
98 std::vector<double> &w )
99 {
100 // computes w = (v1 - v2) * s;
101 size = w.size();
102 assert ( w.size() == v1.size() );
103 for ( int i = 0; i < size; ++i )
104 w[i] = ( v1[i] - v2[i] ) * s;
105 return;
106 }
107 //--------------------------------------------------------------------------------
108
109 //--------------------------------------------------------------------------------
diff_norm(std::vector<double> const & v1,std::vector<double> const & v2)110 double VectorOperations::diff_norm( std::vector<double> const &v1,
111 std::vector<double> const &v2)
112 {
113 // computes ||v1-v2||
114 dbl = 0e0;
115 size = v1.size();
116 for ( int i = 0; i < size; ++i )
117 dbl += pow( v1[i] - v2[i], 2e0 );
118 return sqrt(dbl);
119 }
120 //--------------------------------------------------------------------------------
121
122 //--------------------------------------------------------------------------------
dot_product(std::vector<double> const & v1,std::vector<double> const & v2)123 double VectorOperations::dot_product( std::vector<double> const &v1,
124 std::vector<double> const &v2)
125 {
126 // computes v1.dot(v2)
127 dbl = 0e0;
128 size = v1.size();
129 for ( int i = 0; i < size; ++i )
130 dbl += v1[i] * v2[i];
131 return dbl;
132 }
133 //--------------------------------------------------------------------------------
134
135
136 //--------------------------------------------------------------------------------
mat_transpose(std::vector<std::vector<double>> const & V,std::vector<std::vector<double>> & V_T)137 void VectorOperations::mat_transpose(std::vector<std::vector<double> > const & V, std::vector<std::vector<double> > & V_T) {
138 for(int i = 0; i < V.size(); ++i){
139 for(int j = 0; j < V_T.size(); ++j){
140 V_T[j][i] = V[i][j];
141 }
142 }
143 return ;
144 }
145 //--------------------------------------------------------------------------------
146
147 //--------------------------------------------------------------------------------
mat_product(std::vector<std::vector<double>> const & V1,std::vector<std::vector<double>> const & V2,std::vector<std::vector<double>> & W)148 void VectorOperations::mat_product( std::vector< std::vector<double> > const &V1,
149 std::vector< std::vector<double> > const &V2,
150 std::vector< std::vector<double> > &W )
151 {
152 // computes W = V1 * V2
153 size = V1[0].size();
154 size1 = V1.size();
155 size2 = V2.size();
156 for ( int i = 0; i < V1.size(); ++i ) {
157 for ( int j = 0; j < V2.at(0).size(); ++j ) {
158 W.at(i).at(j) = 0e0;
159 for ( int k = 0; k < V1.at(0).size(); ++k )
160 W.at(i).at(j) += V1.at(i).at(k) * V2.at(k).at(j);
161 }
162 }
163 return;
164 }
165 //--------------------------------------------------------------------------------
166
167 //--------------------------------------------------------------------------------
mat_vec_product(std::vector<std::vector<double>> const & V1,std::vector<double> const & v2,std::vector<double> & w)168 void VectorOperations::mat_vec_product( std::vector< std::vector<double> > const &V1,
169 std::vector<double> const &v2,
170 std::vector<double> &w )
171 {
172 // computes w = V1 * v2
173 size1 = V1.size();
174 size2 = v2.size();
175 for ( int i = 0; i < V1.size(); ++i ) {
176 w.at(i) = 0e0;
177 for ( int j = 0; j < V1.at(i).size(); ++j )
178 w.at(i) += V1.at(i).at(j) * v2.at(j);
179 }
180 return;
181 }
182 //--------------------------------------------------------------------------------
183
184 //--------------------------------------------------------------------------------
mat_square(std::vector<std::vector<double>> const & V,std::vector<std::vector<double>> & W)185 void VectorOperations::mat_square( std::vector< std::vector<double> > const &V,
186 std::vector< std::vector<double> > &W )
187 {
188 // computes W = V' * V
189 size = V[0].size();
190 size1 = V.size();
191 for ( int i = 0; i < size1; ++i ) {
192 for ( int j = 0; j < size1; ++j ) {
193 W[i][j] = 0e0;
194 for ( int k = 0; k < size; ++k )
195 W[i][j] += V[k][i] * V[k][j];
196 }
197 }
198 return;
199 }
200 //--------------------------------------------------------------------------------
201
202 //--------------------------------------------------------------------------------
norm(std::vector<double> const & v)203 double VectorOperations::norm( std::vector<double> const &v )
204 {
205 // computes || v ||
206 dbl = 0e0;
207 size = v.size();
208 for ( int i = 0; i < size; ++i)
209 dbl += pow( v[i], 2e0 );
210 return sqrt(dbl);
211 }
212 //--------------------------------------------------------------------------------
213
214 //--------------------------------------------------------------------------------
norm(std::vector<std::vector<double>> const & V)215 double VectorOperations::norm( std::vector< std::vector<double> > const &V )
216 {
217 // computes || V ||_F
218 assert(V[0].size() == V.size());
219 dbl = 0e0;
220 size = V.size();
221 for ( int i = 0; i < size; ++i ) {
222 for ( int j = 0; j < size; ++j )
223 dbl += pow( V[i][j], 2e0 );
224 }
225 return sqrt(dbl);
226 }
227
vec_mat_product(std::vector<std::vector<double>> const & V1,std::vector<double> const & v2,std::vector<double> & w)228 void VectorOperations::vec_mat_product(std::vector<std::vector<double> > const &V1, std::vector<double> const &v2,
229 std::vector<double> &w)
230 {
231 // computes w = v2^T * V1
232 size1 = V1.size();
233 size2 = v2.size();
234 for ( int j = 0; j < w.size(); ++j ) {
235 w.at(j) = 0e0;
236 for ( int i = 0; i < size1; ++i )
237 w.at(j) += v2.at(i) * V1.at(i).at(j);
238 }
239 return;
240
241 }
242
print_matrix(std::vector<std::vector<double>> const & M)243 void VectorOperations::print_matrix(std::vector<std::vector<double> > const & M) {
244 std::cout << "[";
245 for(int i = 0; i < M.size(); ++i){
246 for(int j = 0; j < M.at(i).size(); ++j){
247 std::cout << M.at(i).at(j) << " ";
248 }
249 std::cout << ";" << std::endl;
250 }
251 std::cout << "]" << std::endl;
252 }
253
print_vector(std::vector<double> const & v)254 void VectorOperations::print_vector(std::vector<double> const & v) {
255 std::cout << "[";
256 for(int i = 0; i < v.size(); ++i){
257 std::cout << v.at(i) << " ";
258 }
259 std::cout << "]" << std::endl;
260 }
261 //--------------------------------------------------------------------------------
262