util.h

Go to the documentation of this file.
00001 /*==============================================================================
00002 
00003    Copyright (C) 1998 - 2008 Rachid Touzani
00004 
00005    This program is free software; you can redistribute it and/or modify it under
00006    the terms of the GNU General Public License as published by the Free
00007    Software Foundation; Version 2 of the License.
00008 
00009    This program is distributed in the hope that it will be useful, but WITHOUT
00010    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00011    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
00012    details.
00013 
00014    You should have received a copy of the GNU General Public License
00015    along with this program; if not, write to the :
00016 
00017    Free Software Foundation
00018    Inc., 59 Temple Place - Suite 330
00019    Boston, MA  02111-1307, USA
00020 
00021   ==============================================================================*/
00022 
00023 #ifndef __UTIL_H
00024 #define __UTIL_H
00025 
00026 #include <complex>
00027 #include <valarray>
00028 #include <vector>
00029 #include <stdio.h>
00030 
00031 #include "OFELI_Config.h"
00032 #include "Point.h"
00033 
00034 using std::valarray;
00035 using std::vector;
00036 
00037 #if !defined ( _MSVCPP_ )
00038 using std::min;
00039 using std::max;
00040 #endif
00041 
00042 namespace OFELI {
00043 
00048 
00049 
00050 
00051 inline int Sgn(double a) { return (((a) > 0) ? (1) : -(1)); }
00052 
00056 inline double Abs2(complex_t a) { return (a.real()*a.real()+a.imag()*a.imag()); }
00057 
00061 inline double Abs2(double a) { return (a*a); }
00062 
00066 inline double Abs(double a) { return (((a) > 0) ? (a) : -(a)); }
00067 
00071 inline double Abs(complex_t a) { return sqrt(Abs2(a)); }
00072 
00076 inline double Abs(const Point<double> &p) { return p.Norm(); }
00077 
00081 inline double Conjg(double a) { return a; }
00082 
00086 inline complex_t Conjg(complex_t a) { complex_t y(a.real(),-a.imag()); return y; }
00087 
00091 inline double Max(double a, double b, double c) { return max(max(a,b),c); }
00092 
00096 inline int Max(int a, int b, int c) { return max(max(a,b),c); }
00097 
00101 inline double Min(double a, double b, double c) { return min(min(a,b),c); }
00102 
00106 inline int  Min(int a, int b, int c) { return min(min(a,b),c); }
00107 
00111 inline double Max(double a, double b, double c, double d)  { return max(Max(a,b,c),d); }
00112 
00116 inline int Max(int a, int b, int  c, int d) { return max(Max(a,b,c),d); }
00117 
00121 inline double Min(double a, double b, double c, double d) { return min(Min(a,b,c),d); }
00122 
00126 inline int Min(int a, int b, int c, int d) { return min(Min(a,b,c),d); }
00127 
00131 inline double Arg(complex_t x)
00132 {
00133   double a = 0.;
00134   if (x.real() == 0.)
00135     a = 0.5*OFELI_PI;
00136   else
00137     a = atan(x.imag()/x.real());
00138   return a;
00139 }
00140 
00141 
00146 inline complex_t Log(complex_t x)
00147 {
00148   return complex_t(log(Abs(x)),Arg(x));
00149 }
00150 
00151 
00155 template<class T_>
00156 inline T_ Sqr(T_ &x)
00157 {
00158    return x*x;
00159 }
00160 
00161 
00167 template<class T_>
00168 inline void Scale(T_ a, const vector<T_> &x, vector<T_> &y)
00169 {
00170    typename std::vector<T_>::const_iterator j = x.begin();
00171    for (typename std::vector<T_>::iterator i=y.begin(); i!=y.end();)
00172       *(++i) = a * *(j++);
00173 }
00174 
00175 
00181 template<class T_>
00182 inline void Scale(T_ a, const valarray<T_> &x, valarray<T_> &y)
00183 {
00184    for (size_t i=0; i<x.size(); ++i)
00185       y[i] = a * x[i];
00186 }
00187 
00188 
00194 template<class T_>
00195 inline void Scale(T_ a, vector<T_> &x)
00196 {
00197    for (typename std::vector<T_>::iterator i=x.begin(); i!=x.end();)
00198       *(++i) *= a;
00199 }
00200 
00201 
00207 template<class T_>
00208 inline void Scale(T_ a, valarray<T_> &x)
00209 {
00210    for (size_t i=0; i<x.size(); ++i)
00211       x[i] *= a;
00212 }
00213 
00214 
00218 template<class T_>
00219 inline void Xpy(size_t n, T_ *x, T_ *y)
00220 {
00221    for (size_t i=0; i<n; ++i)
00222       y[i] += x[i];
00223 }
00224 
00225 
00231 template<class T_>
00232 inline void Xpy(const vector<T_> &x, vector<T_> &y)
00233 {
00234    typename std::vector<T_>::const_iterator j = x.begin();
00235    for (typename std::vector<T_>::iterator i=y.begin(); i!=y.end();)
00236       *(++i) += *(j++);
00237 }
00238 
00239 
00245 template<class T_>
00246 inline void Xpy(const valarray<T_> &x, valarray<T_> &y)
00247 {
00248    for (size_t i=0; i<x.size(); ++i)
00249       y[i] += x[i];
00250 }
00251 
00252 
00258 template<class T_>
00259 inline void Axpy(size_t n, T_ a, T_ *x, T_ *y)
00260 {
00261    for (size_t i=0; i<n; ++i)
00262       y[i] += a*x[i];
00263 }
00264 
00265 
00271 template<class T_>
00272 inline void Axpy(T_ a, const vector<T_> &x, vector<T_> &y)
00273 {
00274    typename std::vector<T_>::const_iterator j = x.begin();
00275    for (typename std::vector<T_>::iterator i=y.begin(); i!=y.end();)
00276       *(++i) += a * *(j++);
00277 }
00278 
00279 
00285 template<class T_>
00286 inline void Axpy(T_ a, const valarray<T_> &x, valarray<T_> &y)
00287 {
00288    for (size_t i=0; i<x.size(); ++i)
00289       y[i] += a*x[i];
00290 }
00291 
00292 
00298 template<class T_>
00299 inline void Copy(size_t n, T_ *x, T_ *y)
00300 {
00301    for (size_t i=0; i<n; ++i)
00302       y[i] = x[i];
00303 }
00304 
00305 
00309 template<class T_>
00310 inline void Copy(const valarray<T_> &x, valarray<T_> &y) { y = x; }
00311 
00312 
00318 template<class T_>
00319 inline T_ Dot(size_t n, T_ *x, T_ *y)
00320 {
00321    T_ d = T_(0);
00322    for (size_t i=0; i<n; ++i)
00323       d += x[i]*Conjg(y[i]);
00324    return d;
00325 }
00326 
00327 
00333 template<class T_>
00334 inline T_ Dot(const vector<T_> &x, const vector<T_> &y)
00335 {
00336    typedef typename std::vector<T_>::const_iterator iter;
00337    T_ d = T_(0);
00338    iter j = x.begin();
00339    for (iter i=y.begin(); i!=y.end();)
00340       d += *(j++) * *(++i);
00341    return d;
00342 }
00343 
00344 
00350 inline real_t Dot(const valarray<real_t> &x, const valarray<real_t> &y)
00351 {
00352    real_t d = 0.;
00353    for (size_t i=0; i<x.size(); ++i)
00354       d += x[i] * y[i];
00355    return d;
00356 }
00357 
00358 
00364 inline complex_t Dot(const valarray<complex_t> &x, const valarray<complex_t> &y)
00365 {
00366    complex_t d = 0.;
00367    for (size_t i=0; i<x.size(); ++i)
00368               d += x[i] * std::conj(y[i]);
00369    return d;
00370 }
00371 
00372 
00376 template<class T_>
00377 inline T_ Dot(const Point<T_> &x, const Point<T_> &y)
00378 {
00379    return (x.x*y.x + x.y*y.y + x.z*y.z);
00380 }
00381 
00382 
00388 inline complex_t CDot(size_t n, const complex_t *x, const complex_t *y)
00389 {
00390    complex_t d=0;
00391    for (size_t i=0; i<n; ++i)
00392       d += x[i]*Conjg(y[i]);
00393    return d;
00394 }
00395 
00396 
00400 inline complex_t CDot(const valarray<complex_t> &x, valarray<complex_t> &y)
00401 {
00402    complex_t d=0;
00403    for (size_t i=0; i<x.size(); ++i)
00404       d += x[i]*Conjg(y[i]);
00405    return d;
00406 }
00407 
00408 
00414 inline double Nrm2(size_t n, double *x) { return sqrt(Dot(n,x,x)); }
00415 
00416 
00421 inline double Nrm2(const valarray<double> &x) { return sqrt(Dot(x,x)); }
00422 
00423 
00428 template<class T_>
00429 inline double Nrm2(const Point<T_> &a) { return sqrt(Dot(a,a)); }
00430 
00431 
00435 template<class T_>
00436 inline void Clear(valarray<T_> &v)
00437 {
00438    for (size_t i=0; i<v.size(); ++i)
00439       v[i] = 0;
00440 }
00441 
00442 
00447 template<class T_>
00448 inline void Clear(vector<T_> &v)
00449 {
00450    for (size_t i=0; i<v.size(); ++i)
00451       v[i] = 0;
00452 }
00453 
00454 
00459 inline char itoc(int i)
00460 {
00461    static char buf[10];
00462    sprintf(buf,"%d",i);
00463    return buf[0];
00464 }
00465 
00466 
00471 inline std::string itos(int i)
00472 {
00473    std::stringstream s;
00474    s << i;
00475    return s.str();
00476 }
00477 
00478 
00483 inline std::string dtos(double d)
00484 {
00485    std::stringstream s;
00486    s << d;
00487    return s.str();
00488 }
00489 
00490 
00495 inline std::string ftos(float f)
00496 {
00497    std::stringstream s;
00498    s << f;
00499    return s.str();
00500 }
00501 
00502 
00507 template <class T_>
00508 T_ stringTo(const std::string &s)
00509 {
00510    T_ val;
00511    std::stringstream sstr(s);
00512    sstr >> val;
00513    return val;
00514 }
00515 
00516 
00521 inline void RTrim(char *s)
00522 {
00523    size_t i = 0;
00524    size_t l = strlen(s) - 1;
00525    if (l > 0) {
00526       i = l;
00527       while (s[i] == ' ')
00528          i--;
00529       if (i < l)
00530          s[i+1] = 0;
00531    }
00532 }
00533 
00534 
00539 inline void LTrim(char *s)
00540 {
00541    size_t i=0, j=0, l=strlen(s)-1;
00542    if (l > 0) {
00543       while (s[i] == ' ')
00544          i++;
00545       if (i > 0) {
00546          for (j=0; j<=l-i; j++)
00547             s[j] = s[i+j];
00548          s[j] = 0;
00549       }
00550    }
00551 }
00552 
00553 
00558 inline void Trim(char *s) { RTrim(s); LTrim(s); }
00559 
00560 
00565 template<class T_>
00566 inline void Swap(T_ &a, T_ &b)
00567 {
00568    T_ t = a;
00569    a = b;
00570    b = t;
00571 }
00572 
00573 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00574 inline std::string zeros(size_t m, size_t n=3)
00575 {
00576    int k=1;
00577    std::string s;
00578    while (m >= pow(10.,k)) {
00579       n--;
00580       k++;
00581    }
00582    for (size_t l=0; l<n; l++)
00583       s += "0";
00584    return s+itos(m);
00585 }
00586 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00587 
00588 } /* namespace OFELI */
00589 
00590 #endif