00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "vector.h"
00025 #include <exception>
00026 #include <core/exceptions/software.h>
00027 #include <cstdlib>
00028 #include <cstdio>
00029
00030 namespace fawkes {
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060 Vector::Vector(unsigned int size, float* data, bool manage_memory)
00061 {
00062 m_size = size;
00063 m_manage_memory = manage_memory;
00064
00065 if (m_manage_memory)
00066 {
00067 m_data = new float[m_size];
00068
00069 for (unsigned int i = 0; i < m_size; ++i)
00070 {
00071 if (data)
00072 { m_data[i] = data[i]; }
00073 else
00074 { m_data[i] = 0.0; }
00075 }
00076 }
00077 else
00078 {
00079 m_data = data;
00080 }
00081 }
00082
00083
00084
00085
00086 Vector::Vector(const Vector& v)
00087 {
00088 m_size = v.m_size;
00089 m_manage_memory = true;
00090 m_data = new float[m_size];
00091
00092 for (unsigned int i = 0; i < m_size; ++i)
00093 {
00094 m_data[i] = v.m_data[i];
00095 }
00096 }
00097
00098
00099 Vector::~Vector()
00100 {
00101 if (m_manage_memory)
00102 {
00103 delete[] m_data;
00104 }
00105 }
00106
00107
00108
00109
00110 unsigned int
00111 Vector::size() const
00112 {
00113 return m_size;
00114 }
00115
00116
00117
00118
00119 void
00120 Vector::set_size(unsigned int size)
00121 {
00122 float* t = new float[size];
00123
00124 unsigned int i = 0;
00125 while( i < size && i < m_size)
00126 {
00127 t[i] = m_data[i];
00128 ++i;
00129 }
00130
00131 m_size = size;
00132
00133 if (m_manage_memory)
00134 { delete[] m_data; }
00135 else
00136 { m_manage_memory = true;}
00137
00138 m_data = t;
00139 }
00140
00141
00142
00143
00144
00145 float
00146 Vector::get(unsigned int d) const
00147 {
00148 if (m_size <= d)
00149 { return 0.0; }
00150
00151 return m_data[d];
00152 }
00153
00154
00155
00156
00157
00158 float&
00159 Vector::get(unsigned int d)
00160 {
00161 if (m_size <= d)
00162 {
00163 printf("This column vector has %u elements -- element %u not "
00164 "available", m_size, d);
00165 throw std::exception();
00166 }
00167
00168 return m_data[d];
00169 }
00170
00171
00172
00173
00174
00175 void
00176 Vector::set(unsigned int d, float f)
00177 {
00178 if (m_size <= d)
00179 {
00180 printf("This column vector has %u elements -- element %u not "
00181 "available", m_size, d);
00182 throw std::exception();
00183 }
00184
00185 m_data[d] = f;
00186 }
00187
00188
00189
00190
00191 float
00192 Vector::x() const
00193 {
00194 return get(0);
00195 }
00196
00197
00198
00199
00200 float&
00201 Vector::x()
00202 {
00203 float& ret = get(0);
00204 return ret;
00205 }
00206
00207
00208
00209
00210 void
00211 Vector::x(float x)
00212 {
00213 set(0, x);
00214 }
00215
00216
00217
00218
00219 float
00220 Vector::y() const
00221 {
00222 return get(1);
00223 }
00224
00225
00226
00227
00228 float&
00229 Vector::y()
00230 {
00231 float& ret = get(1);
00232 return ret;
00233 }
00234
00235
00236
00237
00238 void
00239 Vector::y(float y)
00240 {
00241 set(1, y);
00242 }
00243
00244
00245
00246
00247 float
00248 Vector::z() const
00249 {
00250 return get(2);
00251 }
00252
00253
00254
00255
00256 float&
00257 Vector::z()
00258 {
00259 float& ret = get(2);
00260 return ret;
00261 }
00262
00263
00264
00265
00266 void
00267 Vector::z(float z)
00268 {
00269 set(2, z);
00270 }
00271
00272
00273
00274
00275
00276 float
00277 Vector::operator[](unsigned int d) const
00278 {
00279 if (m_size <= d)
00280 { return 0.0; }
00281
00282 return m_data[d];
00283 }
00284
00285
00286
00287
00288
00289 float&
00290 Vector::operator[](unsigned int d)
00291 {
00292 if (m_size <= d)
00293 {
00294 printf("This column vector has %u elements -- element %u not "
00295 "available", m_size, d);
00296 throw std::exception();
00297 }
00298
00299 return m_data[d];
00300 }
00301
00302
00303
00304
00305
00306 Vector
00307 Vector::operator*(const float& f) const
00308 {
00309 Vector result(m_size, m_data);
00310
00311 for (unsigned int i = 0; i < m_size; ++i)
00312 { result.m_data[i] *= f; }
00313
00314 return result;
00315 }
00316
00317
00318
00319
00320
00321 Vector&
00322 Vector::operator*=(const float& f)
00323 {
00324 for (unsigned int i = 0; i < m_size; ++i)
00325 { m_data[i] *= f; }
00326
00327 return *this;
00328 }
00329
00330
00331
00332
00333
00334 Vector
00335 Vector::operator/(const float& f) const
00336 {
00337 Vector result(m_size, m_data);
00338
00339 for (unsigned int i = 0; i < m_size; ++i)
00340 { result.m_data[i] /= f; }
00341
00342 return result;
00343 }
00344
00345
00346
00347
00348
00349 Vector&
00350 Vector::operator/=(const float& f)
00351 {
00352 for (unsigned int i = 0; i < m_size; ++i)
00353 { m_data[i] /= f; }
00354
00355 return *this;
00356 }
00357
00358
00359
00360
00361
00362 Vector
00363 Vector::operator+(const Vector& cv) const
00364 {
00365 if (m_size != cv.size()) throw fawkes::TypeMismatchException("The two vectors have to be of equal size");
00366
00367 Vector result(m_size, m_data);
00368
00369 for (unsigned int i = 0; i < m_size; ++i)
00370 {
00371 result.m_data[i] += cv[i];
00372 }
00373
00374 return result;
00375 }
00376
00377
00378
00379
00380
00381 Vector&
00382 Vector::operator+=(const Vector& cv)
00383 {
00384 if (m_size != cv.size()) throw fawkes::TypeMismatchException("The two vectors have to be of equal size");
00385
00386 for (unsigned int i = 0; i < m_size; ++i)
00387 {
00388 m_data[i] += cv[i];
00389 }
00390
00391 return *this;
00392 }
00393
00394
00395
00396
00397
00398 Vector
00399 Vector::operator-(const Vector& cv) const
00400 {
00401 if (m_size != cv.size()) throw fawkes::TypeMismatchException("The two vectors have to be of equal size");
00402
00403 Vector result(m_size, m_data);
00404
00405 for (unsigned int i = 0; i < m_size; ++i)
00406 {
00407 result.m_data[i] -= cv[i];
00408 }
00409
00410 return result;
00411 }
00412
00413
00414
00415
00416
00417 Vector&
00418 Vector::operator-=(const Vector& cv)
00419 {
00420 if (m_size != cv.size()) throw fawkes::TypeMismatchException("The two vectors have to be of equal size");
00421
00422 for (unsigned int i = 0; i < m_size; ++i)
00423 {
00424 m_data[i] -= cv[i];
00425 }
00426
00427 return *this;
00428 }
00429
00430
00431
00432
00433
00434 Vector&
00435 Vector::operator=(const Vector& v)
00436 {
00437 if (m_size != v.m_size)
00438 {
00439 if (m_manage_memory)
00440 { delete[] m_data; }
00441
00442 m_size = v.m_size;
00443 m_manage_memory = true;
00444
00445 m_data = new float[m_size];
00446 }
00447
00448 for (unsigned int i = 0; i < m_size; ++i)
00449 { m_data[i] = v.m_data[i]; }
00450
00451 return *this;
00452 }
00453
00454
00455
00456
00457
00458 bool
00459 Vector::operator==(const Vector& v)
00460 {
00461 if (m_size != v.m_size)
00462 { return false; }
00463
00464 for (unsigned int i = 0; i < m_size; ++i)
00465 {
00466 if (m_data[i] != v.m_data[i])
00467 { return false; }
00468 }
00469
00470 return true;
00471 }
00472
00473
00474
00475
00476
00477 void
00478 Vector::print_info(const char* name) const
00479 {
00480 if (name)
00481 { printf("%s: [ ", name); }
00482 else
00483 { printf("[ "); }
00484
00485 for (unsigned int i = 0; i < m_size; ++i)
00486 {
00487 printf("%f ", get(i));
00488 }
00489 printf("]T\n");
00490 }
00491
00492
00493
00494
00495
00496 float
00497 Vector::operator*(const Vector& v) const
00498 {
00499 float res = 0;
00500
00501 for (unsigned int i = 0; i < m_size; ++i)
00502 res += this->get(i) * v.get(i);
00503
00504 return res;
00505 }
00506
00507
00508
00509
00510
00511
00512 std::ostream&
00513 operator<<(std::ostream& stream, const Vector &v)
00514 {
00515 stream << "[";
00516
00517 for (unsigned int i = 0; i < v.m_size; ++i)
00518 {
00519 stream << v.get(i);
00520
00521 if (i + 1 < v.m_size)
00522 stream << ",";
00523 }
00524
00525 return stream << "]";
00526 }
00527
00528 }
00529