vector_math.h

00001 
00024 #pragma once
00025 
00026 #include <usml/ublas/scalar_math.h>
00027 
00028 namespace usml {
00029 namespace ublas {
00030 
00031     //**********************************************************
00032     // scalar addition
00033 
00038     template<class E1, class T2> BOOST_UBLAS_INLINE
00039         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00040         typename vector_binary_scalar2_traits<E1, const T2, scalar_plus<typename E1::value_type, T2> >::result_type
00041         >::type
00042     operator + (const vector_expression<E1> &e1, const T2 &e2) {
00043         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_plus<typename E1::value_type, T2> >::expression_type expression_type;
00044         return expression_type (e1 (), e2);
00045     }
00046     
00051     template<class T1, class E2> BOOST_UBLAS_INLINE
00052         typename boost::enable_if< boost::is_convertible<T1, typename E2::value_type >,    
00053         typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type
00054         >::type
00055     operator + (const T1 &e1, const vector_expression<E2> &e2) {
00056         typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type;
00057         return expression_type (e1, e2 ());
00058     }
00059 
00064     template<class E1, class T2> BOOST_UBLAS_INLINE
00065         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00066         typename vector_binary_scalar2_traits<E1, const T2, scalar_minus<typename E1::value_type, T2> >::result_type
00067         >::type
00068     operator - (const vector_expression<E1> &e1, const T2 &e2) {
00069         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_minus<typename E1::value_type, T2> >::expression_type expression_type;
00070         return expression_type (e1 (), e2);
00071     }
00072 
00077     template<class T1, class E2> BOOST_UBLAS_INLINE
00078         typename boost::enable_if< boost::is_convertible<T1, typename E2::value_type >,    
00079         typename vector_binary_scalar1_traits<const T1, E2, scalar_minus<T1, typename E2::value_type> >::result_type
00080         >::type
00081     operator - (const T1 &e1, const vector_expression<E2> &e2) {
00082         typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_minus<T1, typename E2::value_type> >::expression_type expression_type;
00083         return expression_type (e1, e2 ());
00084     }
00085 
00086     //**********************************************************
00087     // scalar division
00088 
00093     template<class T1, class E2> BOOST_UBLAS_INLINE
00094         typename boost::enable_if< boost::is_convertible<T1, typename E2::value_type >,    
00095         typename vector_binary_scalar1_traits<const T1, E2, scalar_divides<T1, typename E2::value_type> >::result_type
00096         >::type
00097     operator / (const T1 &e1, const vector_expression<E2> &e2) {
00098         typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_divides<T1, typename E2::value_type> >::expression_type expression_type;
00099         return expression_type (e1, e2 ());
00100     }
00101 
00102     //**********************************************************
00103     // element multiplication
00104 
00108     template<class E1, class E2> BOOST_UBLAS_INLINE
00109         typename boost::enable_if< boost::is_convertible< E1, E2 >,
00110             typename vector_binary_traits<E1, E2, scalar_multiplies< 
00111             typename E1::value_type, typename E2::value_type> >::result_type
00112         >::type
00113     operator * ( const vector_expression<E1> &u, const vector_expression<E2> &v ) {
00114         return element_prod( u(), v() ) ;
00115     }
00116 
00120     template<class E1, class E2> BOOST_UBLAS_INLINE
00121         typename boost::enable_if< boost::is_convertible< E1, E2 >,
00122             typename vector_binary_traits<E1, E2, scalar_divides< 
00123             typename E1::value_type, typename E2::value_type> >::result_type
00124         >::type
00125     operator / ( const vector_expression<E1> &u, const vector_expression<E2> &v ) {
00126         return element_div( u(), v() ) ;
00127     }
00128 
00129     //**********************************************************
00130     // limiting functions
00131 
00138     template<class E1, class T2> BOOST_UBLAS_INLINE
00139         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00140         typename vector_binary_scalar2_traits<E1, const T2, scalar_max<typename E1::value_type, T2> >::result_type
00141         >::type
00142     max (const vector_expression<E1> &e1, const T2 &e2) {
00143         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_max<typename E1::value_type, T2> >::expression_type expression_type;
00144         return expression_type (e1 (), e2);
00145     }
00146 
00153     template<class E1, class T2> BOOST_UBLAS_INLINE
00154         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00155         typename vector_binary_scalar2_traits<E1, const T2, scalar_min<typename E1::value_type, T2> >::result_type
00156         >::type
00157     min (const vector_expression<E1> &e1, const T2 &e2) {
00158         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_min<typename E1::value_type, T2> >::expression_type expression_type;
00159         return expression_type (e1 (), e2);
00160     }
00161 
00166     template<class E> BOOST_UBLAS_INLINE
00167         typename vector_unary_traits<E,
00168         scalar_floor<typename E::value_type> >::result_type
00169     floor(const vector_expression<E> &e) {
00170         typedef typename vector_unary_traits<E,
00171         scalar_floor<typename E::value_type> >::expression_type
00172             expression_type;
00173         return expression_type( e() );
00174     }
00175 
00180     template<class E> BOOST_UBLAS_INLINE
00181         typename vector_unary_traits<E,
00182         scalar_ceil<typename E::value_type> >::result_type
00183     ceil(const vector_expression<E> &e) {
00184         typedef typename vector_unary_traits<E,
00185         scalar_ceil<typename E::value_type> >::expression_type
00186             expression_type;
00187         return expression_type( e() );
00188     }
00189 
00190     //**********************************************************
00191     // conversion functions
00192 
00196     template<class E> BOOST_UBLAS_INLINE
00197         typename vector_unary_traits<E,
00198         scalar_to_degrees<typename E::value_type> >::result_type
00199     to_degrees(const vector_expression<E> &e) {
00200         typedef typename vector_unary_traits<E,
00201         scalar_to_degrees<typename E::value_type> >::expression_type
00202             expression_type;
00203         return expression_type( e() );
00204     }
00205      
00209     template<class E> BOOST_UBLAS_INLINE
00210         typename vector_unary_traits<E,
00211         scalar_to_radians<typename E::value_type> >::result_type
00212     to_radians(const vector_expression<E> &e) {
00213         typedef typename vector_unary_traits<E,
00214         scalar_to_radians<typename E::value_type> >::expression_type
00215             expression_type;
00216         return expression_type( e() );
00217     }
00218      
00223     template<class E> BOOST_UBLAS_INLINE
00224         typename vector_unary_traits<E,
00225         scalar_to_latitude<typename E::value_type> >::result_type
00226     to_latitude(const vector_expression<E> &e) {
00227         typedef typename vector_unary_traits<E,
00228         scalar_to_latitude<typename E::value_type> >::expression_type
00229             expression_type;
00230         return expression_type( e() );
00231     }
00232      
00237     template<class E> BOOST_UBLAS_INLINE
00238         typename vector_unary_traits<E,
00239         scalar_to_colatitude<typename E::value_type> >::result_type
00240     to_colatitude(const vector_expression<E> &e) {
00241         typedef typename vector_unary_traits<E,
00242         scalar_to_colatitude<typename E::value_type> >::expression_type
00243             expression_type;
00244         return expression_type( e() );
00245     }
00246      
00247     //**********************************************************
00248     // algebraic functions
00249 
00253     template<class E> BOOST_UBLAS_INLINE
00254         typename vector_unary_traits<E,
00255         scalar_abs<typename E::value_type> >::result_type
00256     abs(const vector_expression<E> &e) {
00257         typedef typename vector_unary_traits<E,
00258         scalar_abs<typename E::value_type> >::expression_type
00259             expression_type;
00260         return expression_type( e() );
00261     }
00262 
00266     template<class E> BOOST_UBLAS_INLINE
00267         typename vector_unary_traits<E,
00268         scalar_abs2<typename E::value_type> >::result_type
00269     abs2(const vector_expression<E> &e) {
00270         typedef typename vector_unary_traits<E,
00271         scalar_abs2<typename E::value_type> >::expression_type
00272             expression_type;
00273         return expression_type( e() );
00274     }
00275 
00279     template<class E> BOOST_UBLAS_INLINE
00280         typename vector_unary_traits<E,
00281         scalar_arg<typename E::value_type> >::result_type
00282     arg(const vector_expression<E> &e) {
00283         typedef typename vector_unary_traits<E,
00284         scalar_arg<typename E::value_type> >::expression_type
00285             expression_type;
00286         return expression_type( e() );
00287     }
00288 
00292     template<class E> BOOST_UBLAS_INLINE
00293         typename vector_unary_traits<E,
00294         scalar_sqrt<typename E::value_type> >::result_type
00295     sqrt(const vector_expression<E> &e) {
00296         typedef typename vector_unary_traits<E,
00297         scalar_sqrt<typename E::value_type> >::expression_type
00298             expression_type;
00299         return expression_type( e() );
00300     }
00301 
00307     template<class E1, class E2> BOOST_UBLAS_INLINE
00308         typename vector_binary_traits<E1, E2, scalar_copysign< 
00309         typename E1::value_type, typename E2::value_type> >::result_type
00310     copysign( const vector_expression<E1> &u, const vector_expression<E2> &v ) {
00311         typedef typename vector_binary_traits<E1, E2, 
00312         scalar_copysign< typename E1::value_type, typename E2::value_type> 
00313         >::expression_type expression_type;
00314         return expression_type( u(), v() );
00315     }
00316 
00317     //**********************************************************
00318     // standard trigonometric functions
00319 
00323     template<class E> BOOST_UBLAS_INLINE
00324         typename vector_unary_traits<E,
00325         scalar_cos<typename E::value_type> >::result_type
00326     cos(const vector_expression<E> &e) {
00327         typedef typename vector_unary_traits<E,
00328         scalar_cos<typename E::value_type> >::expression_type
00329             expression_type;
00330         return expression_type( e() );
00331     }
00332 
00336     template<class E> BOOST_UBLAS_INLINE
00337         typename vector_unary_traits<E,
00338         scalar_cosh<typename E::value_type> >::result_type
00339     cosh(const vector_expression<E> &e) {
00340         typedef typename vector_unary_traits<E,
00341         scalar_cosh<typename E::value_type> >::expression_type
00342             expression_type;
00343         return expression_type( e() );
00344     }
00345 
00349     template<class E> BOOST_UBLAS_INLINE
00350         typename vector_unary_traits<E,
00351         scalar_sin<typename E::value_type> >::result_type
00352     sin(const vector_expression<E> &e) {
00353         typedef typename vector_unary_traits<E,
00354         scalar_sin<typename E::value_type> >::expression_type
00355             expression_type;
00356         return expression_type( e() );
00357     }
00358 
00362     template<class E> BOOST_UBLAS_INLINE
00363         typename vector_unary_traits<E,
00364         scalar_sinh<typename E::value_type> >::result_type
00365     sinh(const vector_expression<E> &e) {
00366         typedef typename vector_unary_traits<E,
00367         scalar_sinh<typename E::value_type> >::expression_type
00368             expression_type;
00369         return expression_type( e() );
00370     }
00371 
00375     template<class E> BOOST_UBLAS_INLINE
00376         typename vector_unary_traits<E,
00377         scalar_tan<typename E::value_type> >::result_type
00378     tan(const vector_expression<E> &e) {
00379         typedef typename vector_unary_traits<E,
00380         scalar_tan<typename E::value_type> >::expression_type
00381             expression_type;
00382         return expression_type( e() );
00383     }
00384 
00388     template<class E> BOOST_UBLAS_INLINE
00389         typename vector_unary_traits<E,
00390         scalar_tanh<typename E::value_type> >::result_type
00391     tanh(const vector_expression<E> &e) {
00392         typedef typename vector_unary_traits<E,
00393         scalar_tanh<typename E::value_type> >::expression_type
00394             expression_type;
00395         return expression_type( e() );
00396     }
00397 
00398     //**********************************************************
00399     // inverse trigonometric functions
00400 
00404     template<class E> BOOST_UBLAS_INLINE
00405         typename vector_unary_traits<E,
00406         scalar_acos<typename E::value_type> >::result_type
00407     acos(const vector_expression<E> &e) {
00408         typedef typename vector_unary_traits<E,
00409         scalar_acos<typename E::value_type> >::expression_type
00410             expression_type;
00411         return expression_type( e() );
00412     }
00413 
00417     template<class E> BOOST_UBLAS_INLINE
00418         typename vector_unary_traits<E,
00419         scalar_acosh<typename E::value_type> >::result_type
00420     acosh(const vector_expression<E> &e) {
00421         typedef typename vector_unary_traits<E,
00422         scalar_acosh<typename E::value_type> >::expression_type
00423             expression_type;
00424         return expression_type( e() );
00425     }
00426 
00430     template<class E> BOOST_UBLAS_INLINE
00431         typename vector_unary_traits<E,
00432         scalar_asin<typename E::value_type> >::result_type
00433     asin(const vector_expression<E> &e) {
00434         typedef typename vector_unary_traits<E,
00435         scalar_asin<typename E::value_type> >::expression_type
00436             expression_type;
00437         return expression_type( e() );
00438     }
00439 
00443     template<class E> BOOST_UBLAS_INLINE
00444         typename vector_unary_traits<E,
00445         scalar_asinh<typename E::value_type> >::result_type
00446     asinh(const vector_expression<E> &e) {
00447         typedef typename vector_unary_traits<E,
00448         scalar_asinh<typename E::value_type> >::expression_type
00449             expression_type;
00450         return expression_type( e() );
00451     }
00452 
00456     template<class E> BOOST_UBLAS_INLINE
00457         typename vector_unary_traits<E, 
00458         scalar_atan<typename E::value_type> >::result_type
00459     atan(const vector_expression<E> &e) {
00460         typedef typename vector_unary_traits<E,
00461         scalar_atan<typename E::value_type> >::expression_type
00462             expression_type;
00463         return expression_type( e() );
00464     }
00465 
00469     template<class E1, class E2> BOOST_UBLAS_INLINE
00470         typename vector_binary_traits<E1, E2, scalar_atan2< 
00471         typename E1::value_type, typename E2::value_type> >::result_type
00472     atan2( const vector_expression<E1> &y, const vector_expression<E2> &x ) {
00473         typedef typename vector_binary_traits<E1, E2, 
00474         scalar_atan2< typename E1::value_type, typename E2::value_type> 
00475         >::expression_type expression_type;
00476         return expression_type( y(), x() );
00477     }
00478 
00482     template<class E> BOOST_UBLAS_INLINE
00483         typename vector_unary_traits<E,
00484         scalar_atanh<typename E::value_type> >::result_type
00485     atanh(const vector_expression<E> &e) {
00486         typedef typename vector_unary_traits<E,
00487         scalar_atanh<typename E::value_type> >::expression_type
00488             expression_type;
00489         return expression_type( e() );
00490     }
00491 
00492     //**********************************************************
00493     // standard exponential functions
00494 
00498     template<class E> BOOST_UBLAS_INLINE
00499         typename vector_unary_traits<E,
00500         scalar_exp<typename E::value_type> >::result_type
00501     exp(const vector_expression<E> &e) {
00502         typedef typename vector_unary_traits<E,
00503         scalar_exp<typename E::value_type> >::expression_type
00504             expression_type;
00505         return expression_type( e() );
00506     }
00507 
00511     template<class E> BOOST_UBLAS_INLINE
00512         typename vector_unary_traits<E,
00513         scalar_log<typename E::value_type> >::result_type
00514     log(const vector_expression<E> &e) {
00515         typedef typename vector_unary_traits<E,
00516         scalar_log<typename E::value_type> >::expression_type
00517             expression_type;
00518         return expression_type( e() );
00519     }
00520 
00524     template<class E> BOOST_UBLAS_INLINE
00525         typename vector_unary_traits<E,
00526         scalar_log10<typename E::value_type> >::result_type
00527     log10(const vector_expression<E> &e) {
00528         typedef typename vector_unary_traits<E,
00529         scalar_log10<typename E::value_type> >::expression_type
00530             expression_type;
00531         return expression_type( e() );
00532     }
00533 
00538     template<class E1, class T2> BOOST_UBLAS_INLINE
00539         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00540         typename vector_binary_scalar2_traits<E1, const T2, scalar_pow<typename E1::value_type, T2> >::result_type
00541         >::type
00542     pow (const vector_expression<E1> &e1, const T2 &e2) {
00543         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_pow<typename E1::value_type, T2> >::expression_type expression_type;
00544         return expression_type (e1 (), e2);
00545     }
00546 
00551     template<class T1, class E2> BOOST_UBLAS_INLINE
00552         typename boost::enable_if< boost::is_convertible<T1, typename E2::value_type >,    
00553         typename vector_binary_scalar1_traits<const T1, E2, scalar_pow<T1, typename E2::value_type> >::result_type
00554         >::type
00555     pow (const T1 &e1, const vector_expression<E2> &e2) {
00556         typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_pow<T1, typename E2::value_type> >::expression_type expression_type;
00557         return expression_type (e1, e2 ());
00558     }
00559 
00564     template<class E1, class E2> BOOST_UBLAS_INLINE
00565         typename vector_binary_traits<E1, E2, scalar_pow< 
00566         typename E1::value_type, typename E2::value_type> >::result_type
00567     pow( const vector_expression<E1> &u, const vector_expression<E2> &v ) {
00568         typedef typename vector_binary_traits<E1, E2, 
00569         scalar_pow< typename E1::value_type, typename E2::value_type> 
00570         >::expression_type expression_type;
00571         return expression_type( u(), v() );
00572     }
00573 
00574     //**********************************************************
00575     // signal processing functions
00576 
00581     template<class E> BOOST_UBLAS_INLINE
00582         typename vector_unary_traits<E,
00583         scalar_signal<typename E::value_type> >::result_type
00584     signal(const vector_expression<E> &e) {
00585         typedef typename vector_unary_traits<E,
00586             scalar_signal<typename E::value_type> >::expression_type
00587             expression_type;
00588         return expression_type( e() );
00589     }
00590 
00595     template<class E> BOOST_UBLAS_INLINE
00596         typename vector_unary_traits<E,
00597         scalar_asignal<typename E::value_type> >::result_type
00598     asignal(const vector_expression<E> &e) {
00599         typedef typename vector_unary_traits<E,
00600             scalar_asignal<typename E::value_type> >::expression_type
00601             expression_type;
00602         return expression_type( e() );
00603     }
00604 
00605 } // end of ublas namespace
00606 } // end of usml namespace

Generated on 4 May 2015 for USML by  doxygen 1.6.1