matrix_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 matrix_binary_scalar2_traits<E1, const T2, scalar_plus<typename E1::value_type, T2> >::result_type
00041         >::type
00042     operator + (const matrix_expression<E1> &e1, const T2 &e2) {
00043         typedef typename matrix_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 matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type
00054         >::type
00055     operator + (const T1 &e1, const matrix_expression<E2> &e2) {
00056         typedef typename matrix_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 matrix_binary_scalar2_traits<E1, const T2, scalar_minus<typename E1::value_type, T2> >::result_type
00067         >::type
00068     operator - (const matrix_expression<E1> &e1, const T2 &e2) {
00069         typedef typename matrix_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 matrix_binary_scalar1_traits<const T1, E2, scalar_minus<T1, typename E2::value_type> >::result_type
00080         >::type
00081     operator - (const T1 &e1, const matrix_expression<E2> &e2) {
00082         typedef typename matrix_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 matrix_binary_scalar1_traits<const T1, E2, scalar_divides<T1, typename E2::value_type> >::result_type
00096         >::type
00097     operator / (const T1 &e1, const matrix_expression<E2> &e2) {
00098         typedef typename matrix_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 matrix_binary_traits<E1, E2, scalar_multiplies< 
00111             typename E1::value_type, typename E2::value_type> >::result_type
00112         >::type
00113     operator * ( const matrix_expression<E1> &u, const matrix_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 matrix_binary_traits<E1, E2, scalar_divides< 
00123             typename E1::value_type, typename E2::value_type> >::result_type
00124         >::type
00125     operator / ( const matrix_expression<E1> &u, const matrix_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 matrix_binary_scalar2_traits<E1, const T2, scalar_max<typename E1::value_type, T2> >::result_type
00141         >::type
00142     max (const matrix_expression<E1> &e1, const T2 &e2) {
00143         typedef typename matrix_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 matrix_binary_scalar2_traits<E1, const T2, scalar_min<typename E1::value_type, T2> >::result_type
00156         >::type
00157     min (const matrix_expression<E1> &e1, const T2 &e2) {
00158         typedef typename matrix_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 matrix_unary1_traits<E,
00168         scalar_floor<typename E::value_type> >::result_type
00169     floor(const matrix_expression<E> &e) {
00170         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00182         scalar_ceil<typename E::value_type> >::result_type
00183     ceil(const matrix_expression<E> &e) {
00184         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00198         scalar_to_degrees<typename E::value_type> >::result_type
00199     to_degrees(const matrix_expression<E> &e) {
00200         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00211         scalar_to_radians<typename E::value_type> >::result_type
00212     to_radians(const matrix_expression<E> &e) {
00213         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00225         scalar_to_latitude<typename E::value_type> >::result_type
00226     to_latitude(const matrix_expression<E> &e) {
00227         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00239         scalar_to_colatitude<typename E::value_type> >::result_type
00240     to_colatitude(const matrix_expression<E> &e) {
00241         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00255         scalar_abs<typename E::value_type> >::result_type
00256     abs(const matrix_expression<E> &e) {
00257         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00268         scalar_abs2<typename E::value_type> >::result_type
00269     abs2(const matrix_expression<E> &e) {
00270         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00281         scalar_arg<typename E::value_type> >::result_type
00282     arg(const matrix_expression<E> &e) {
00283         typedef typename matrix_unary1_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 matrix_unary1_traits<E,
00294         scalar_sqrt<typename E::value_type> >::result_type
00295     sqrt(const matrix_expression<E> &e) {
00296         typedef typename matrix_unary1_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 matrix_binary_traits<E1, E2, scalar_copysign< 
00309         typename E1::value_type, typename E2::value_type> >::result_type
00310     copysign( const matrix_expression<E1> &u, const matrix_expression<E2> &v ) {
00311         typedef typename matrix_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     //**********************************************************
00319     // standard trigonometric functions
00320 
00324     template<class E> BOOST_UBLAS_INLINE
00325         typename matrix_unary1_traits<E,
00326         scalar_cos<typename E::value_type> >::result_type
00327     cos(const matrix_expression<E> &e) {
00328         typedef typename matrix_unary1_traits<E,
00329         scalar_cos<typename E::value_type> >::expression_type
00330             expression_type;
00331         return expression_type( e() );
00332     }
00333 
00337     template<class E> BOOST_UBLAS_INLINE
00338         typename matrix_unary1_traits<E,
00339         scalar_cosh<typename E::value_type> >::result_type
00340     cosh(const matrix_expression<E> &e) {
00341         typedef typename matrix_unary1_traits<E,
00342         scalar_cosh<typename E::value_type> >::expression_type
00343             expression_type;
00344         return expression_type( e() );
00345     }
00346 
00350     template<class E> BOOST_UBLAS_INLINE
00351         typename matrix_unary1_traits<E,
00352         scalar_sin<typename E::value_type> >::result_type
00353     sin(const matrix_expression<E> &e) {
00354         typedef typename matrix_unary1_traits<E,
00355         scalar_sin<typename E::value_type> >::expression_type
00356             expression_type;
00357         return expression_type( e() );
00358     }
00359 
00363     template<class E> BOOST_UBLAS_INLINE
00364         typename matrix_unary1_traits<E,
00365         scalar_sinh<typename E::value_type> >::result_type
00366     sinh(const matrix_expression<E> &e) {
00367         typedef typename matrix_unary1_traits<E,
00368         scalar_sinh<typename E::value_type> >::expression_type
00369             expression_type;
00370         return expression_type( e() );
00371     }
00372 
00376     template<class E> BOOST_UBLAS_INLINE
00377         typename matrix_unary1_traits<E,
00378         scalar_tan<typename E::value_type> >::result_type
00379     tan(const matrix_expression<E> &e) {
00380         typedef typename matrix_unary1_traits<E,
00381         scalar_tan<typename E::value_type> >::expression_type
00382             expression_type;
00383         return expression_type( e() );
00384     }
00385 
00389     template<class E> BOOST_UBLAS_INLINE
00390         typename matrix_unary1_traits<E,
00391         scalar_tanh<typename E::value_type> >::result_type
00392     tanh(const matrix_expression<E> &e) {
00393         typedef typename matrix_unary1_traits<E,
00394         scalar_tanh<typename E::value_type> >::expression_type
00395             expression_type;
00396         return expression_type( e() );
00397     }
00398 
00399     //**********************************************************
00400     // inverse trigonometric functions
00401 
00405     template<class E> BOOST_UBLAS_INLINE
00406         typename matrix_unary1_traits<E,
00407         scalar_acos<typename E::value_type> >::result_type
00408     acos(const matrix_expression<E> &e) {
00409         typedef typename matrix_unary1_traits<E,
00410         scalar_acos<typename E::value_type> >::expression_type
00411             expression_type;
00412         return expression_type( e() );
00413     }
00414 
00418     template<class E> BOOST_UBLAS_INLINE
00419         typename matrix_unary1_traits<E,
00420         scalar_acosh<typename E::value_type> >::result_type
00421     acosh(const matrix_expression<E> &e) {
00422         typedef typename matrix_unary1_traits<E,
00423         scalar_acosh<typename E::value_type> >::expression_type
00424             expression_type;
00425         return expression_type( e() );
00426     }
00427 
00431     template<class E> BOOST_UBLAS_INLINE
00432         typename matrix_unary1_traits<E,
00433         scalar_asin<typename E::value_type> >::result_type
00434     asin(const matrix_expression<E> &e) {
00435         typedef typename matrix_unary1_traits<E,
00436         scalar_asin<typename E::value_type> >::expression_type
00437             expression_type;
00438         return expression_type( e() );
00439     }
00440 
00444     template<class E> BOOST_UBLAS_INLINE
00445         typename matrix_unary1_traits<E,
00446         scalar_asinh<typename E::value_type> >::result_type
00447     asinh(const matrix_expression<E> &e) {
00448         typedef typename matrix_unary1_traits<E,
00449         scalar_asinh<typename E::value_type> >::expression_type
00450             expression_type;
00451         return expression_type( e() );
00452     }
00453 
00457     template<class E> BOOST_UBLAS_INLINE
00458         typename matrix_unary1_traits<E, 
00459         scalar_atan<typename E::value_type> >::result_type
00460     atan(const matrix_expression<E> &e) {
00461         typedef typename matrix_unary1_traits<E,
00462         scalar_atan<typename E::value_type> >::expression_type
00463             expression_type;
00464         return expression_type( e() );
00465     }
00466 
00470     template<class E1, class E2> BOOST_UBLAS_INLINE
00471         typename matrix_binary_traits<E1, E2, scalar_atan2< 
00472         typename E1::value_type, typename E2::value_type> >::result_type
00473     atan2( const matrix_expression<E1> &y, const matrix_expression<E2> &x ) {
00474         typedef typename matrix_binary_traits<E1, E2, 
00475         scalar_atan2< typename E1::value_type, typename E2::value_type> 
00476         >::expression_type expression_type;
00477         return expression_type( y(), x() );
00478     }
00479 
00483     template<class E> BOOST_UBLAS_INLINE
00484         typename matrix_unary1_traits<E,
00485         scalar_atanh<typename E::value_type> >::result_type
00486     atanh(const matrix_expression<E> &e) {
00487         typedef typename matrix_unary1_traits<E,
00488         scalar_atanh<typename E::value_type> >::expression_type
00489             expression_type;
00490         return expression_type( e() );
00491     }
00492 
00493     //**********************************************************
00494     // standard exponential functions
00495 
00499     template<class E> BOOST_UBLAS_INLINE
00500         typename matrix_unary1_traits<E,
00501         scalar_exp<typename E::value_type> >::result_type
00502     exp(const matrix_expression<E> &e) {
00503         typedef typename matrix_unary1_traits<E,
00504         scalar_exp<typename E::value_type> >::expression_type
00505             expression_type;
00506         return expression_type( e() );
00507     }
00508 
00512     template<class E> BOOST_UBLAS_INLINE
00513         typename matrix_unary1_traits<E,
00514         scalar_log<typename E::value_type> >::result_type
00515     log(const matrix_expression<E> &e) {
00516         typedef typename matrix_unary1_traits<E,
00517         scalar_log<typename E::value_type> >::expression_type
00518             expression_type;
00519         return expression_type( e() );
00520     }
00521 
00525     template<class E> BOOST_UBLAS_INLINE
00526         typename matrix_unary1_traits<E,
00527         scalar_log10<typename E::value_type> >::result_type
00528     log10(const matrix_expression<E> &e) {
00529         typedef typename matrix_unary1_traits<E,
00530         scalar_log10<typename E::value_type> >::expression_type
00531             expression_type;
00532         return expression_type( e() );
00533     }
00534 
00539     template<class E1, class T2> BOOST_UBLAS_INLINE
00540         typename boost::enable_if< boost::is_convertible< T2, typename E1::value_type >,    
00541         typename matrix_binary_scalar2_traits<E1, const T2, scalar_pow<typename E1::value_type, T2> >::result_type
00542         >::type
00543     pow (const matrix_expression<E1> &e1, const T2 &e2) {
00544         typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_pow<typename E1::value_type, T2> >::expression_type expression_type;
00545         return expression_type (e1 (), e2);
00546     }
00547 
00552     template<class T1, class E2> BOOST_UBLAS_INLINE
00553         typename boost::enable_if< boost::is_convertible<T1, typename E2::value_type >,    
00554         typename matrix_binary_scalar1_traits<const T1, E2, scalar_pow<T1, typename E2::value_type> >::result_type
00555         >::type
00556     pow (const T1 &e1, const matrix_expression<E2> &e2) {
00557         typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_pow<T1, typename E2::value_type> >::expression_type expression_type;
00558         return expression_type (e1, e2 ());
00559     }
00560 
00565     template<class E1, class E2> BOOST_UBLAS_INLINE
00566         typename matrix_binary_traits<E1, E2, scalar_pow< 
00567         typename E1::value_type, typename E2::value_type> >::result_type
00568     pow( const matrix_expression<E1> &u, const matrix_expression<E2> &v ) {
00569         typedef typename matrix_binary_traits<E1, E2, 
00570         scalar_pow< typename E1::value_type, typename E2::value_type> 
00571         >::expression_type expression_type;
00572         return expression_type( u(), v() );
00573     }
00574 
00575     //**********************************************************
00576     // signal processing functions
00577 
00582     template<class E> BOOST_UBLAS_INLINE
00583         typename matrix_unary1_traits<E,
00584         scalar_signal<typename E::value_type> >::result_type
00585     signal(const matrix_expression<E> &e) {
00586         typedef typename matrix_unary1_traits<E,
00587             scalar_signal<typename E::value_type> >::expression_type
00588             expression_type;
00589         return expression_type( e() );
00590     }
00591 
00596     template<class E> BOOST_UBLAS_INLINE
00597         typename matrix_unary1_traits<E,
00598         scalar_asignal<typename E::value_type> >::result_type
00599     asignal(const matrix_expression<E> &e) {
00600         typedef typename matrix_unary1_traits<E,
00601             scalar_asignal<typename E::value_type> >::expression_type
00602             expression_type;
00603         return expression_type( e() );
00604     }
00605 
00606 } // end of ublas namespace
00607 } // end of usml namespace

Generated on 4 May 2015 for USML by  doxygen 1.6.1