The MRPT project: matrices_metaprogramming.h Source File

00001 /* +---------------------------------------------------------------------------+
00002    |          The Mobile Robot Programming Toolkit (MRPT) C++ library          |
00003    |                                                                           |
00004    |                   http://mrpt.sourceforge.net/                            |
00005    |                                                                           |
00006    |   Copyright (C) 2005-2010  University of Malaga                           |
00007    |                                                                           |
00008    |    This software was written by the Machine Perception and Intelligent    |
00009    |      Robotics Lab, University of Malaga (Spain).                          |
00010    |    Contact: Jose-Luis Blanco  <jlblanco@ctima.uma.es>                     |
00011    |                                                                           |
00012    |  This file is part of the MRPT project.                                   |
00013    |                                                                           |
00014    |     MRPT is free software: you can redistribute it and/or modify          |
00015    |     it under the terms of the GNU General Public License as published by  |
00016    |     the Free Software Foundation, either version 3 of the License, or     |
00017    |     (at your option) any later version.                                   |
00018    |                                                                           |
00019    |   MRPT is distributed in the hope that it will be useful,                 |
00020    |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
00021    |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
00022    |     GNU General Public License for more details.                          |
00023    |                                                                           |
00024    |     You should have received a copy of the GNU General Public License     |
00025    |     along with MRPT.  If not, see <http://www.gnu.org/licenses/>.         |
00026    |                                                                           |
00027    +---------------------------------------------------------------------------+ */
00028 #ifndef  mrpt_matrices_metaprogramming_H
00029 #define  mrpt_matrices_metaprogramming_H
00030 
00031 #include <mrpt/math/math_frwds.h>  // Fordward declarations
00032 
00033 namespace mrpt { namespace math { namespace detail
00034 {
00035         /** @name Matrix metaprogramming helpers @{ */
00036 
00037         /** TMatrixProductType: Metaprogramming helper to determine the type of the product of two matrices,
00038           * in compile time.  This assume usage ofDECLARE_MRPT_CONTAINER_IS_MATRIX and DECLARE_MRPT_CONTAINER_IS_MATRIX_FIXED
00039           * Example of usage with the helper macro  MAT_TYPE_PRODUCT_OF():
00040           *
00041           * \code
00042           *   void f(MAT1 m1,MAT2 m2) {
00043           *     MAT_TYPE_PRODUCT_OF(MAT1,MAT2) res;
00044           *     res = m1*m2;
00045           *     ...
00046           * \endcode
00047           */
00048         template <typename T,size_t NR1,size_t NC1,size_t NR2,size_t NC2>
00049         struct TMatrixProductType // FIX * FIX -> FIX
00050         {
00051                 typedef CMatrixFixedNumeric<T,NR1,NC2> mat_type;
00052         };
00053 
00054         template <typename T>  // DYN * DYN -> DYN
00055         struct TMatrixProductType<T,size_t(-1),size_t(-1),size_t(-1),size_t(-1)>
00056         {
00057                 typedef CMatrixTemplateNumeric<T> mat_type;
00058         };
00059 
00060         template <typename T,size_t NR1,size_t NC1>  // FIX * DYN -> DYN
00061         struct TMatrixProductType<T,NR1,NC1,size_t(-1),size_t(-1)>
00062         {
00063                 typedef CMatrixTemplateNumeric<T> mat_type;
00064         };
00065 
00066         template <typename T,size_t NR2,size_t NC2>  // DYN * FIX -> DYN
00067         struct TMatrixProductType<T,size_t(-1),size_t(-1),NR2,NC2>
00068         {
00069                 typedef CMatrixTemplateNumeric<T> mat_type;
00070         };
00071 
00072 
00073         // Macro for easy usage of "TMatrixProductType":
00074         // For use out of templates:
00075         #define MAT_TYPEDECL_PRODUCT_OF(MAT_1,MAT_2) \
00076                 mrpt::math::detail::TMatrixProductType< \
00077                         MAT_1::value_type, \
00078                         MAT_1::mrpt_matrix_type_nrows, \
00079                         MAT_1::mrpt_matrix_type_ncols, \
00080                         MAT_2::mrpt_matrix_type_nrows, \
00081                         MAT_2::mrpt_matrix_type_ncols>::mat_type
00082 
00083         // For use within templates:
00084         #define MAT_TYPE_PRODUCT_OF(MAT_1,MAT_2) \
00085                 typename mrpt::math::detail::TMatrixProductType< \
00086                         typename MAT_1::value_type, \
00087                         MAT_1::mrpt_matrix_type_nrows, \
00088                         MAT_1::mrpt_matrix_type_ncols, \
00089                         MAT_2::mrpt_matrix_type_nrows, \
00090                         MAT_2::mrpt_matrix_type_ncols>::mat_type
00091 
00092 
00093         /** TMatrixTransposeType: Metaprogramming helper to determine the type of the transpose of a matrix in compile time.
00094           * This assume usage of DECLARE_MRPT_CONTAINER_IS_MATRIX and DECLARE_MRPT_CONTAINER_IS_MATRIX_FIXED.
00095           * Example of usage with the helper macro  MAT_TYPE_TRANSPOSE_OF():
00096           *
00097           * \code
00098           *   void f(MAT1 m1) {
00099           *     MAT_TYPE_TRANSPOSE_OF(MAT1) res = ~m1;
00100           *     ...
00101           * \endcode
00102           */
00103         template <typename T,size_t NR1,size_t NC1>
00104         struct TMatrixTransposeType // FIX -> FIX
00105         {
00106                 typedef CMatrixFixedNumeric<T,NC1,NR1> mat_type;
00107         };
00108 
00109         template <typename T>  // DYN -> DYN
00110         struct TMatrixTransposeType<T,size_t(-1),size_t(-1)>
00111         {
00112                 typedef CMatrixTemplateNumeric<T> mat_type;
00113         };
00114 
00115         // Macro for easy usage of "TMatrixProductType":
00116         // For use out of templates:
00117         #define MAT_TYPEDECL_TRANSPOSE_OF(MAT) \
00118                 mrpt::math::detail::TMatrixTransposeType< \
00119                         MAT::value_type, \
00120                         MAT::mrpt_matrix_type_nrows, \
00121                         MAT::mrpt_matrix_type_ncols>::mat_type
00122                         
00123         // For use within templates:
00124         #define MAT_TYPE_TRANSPOSE_OF(MAT) \
00125                 typename mrpt::math::detail::TMatrixTransposeType< \
00126                         typename MAT::value_type, \
00127                         MAT::mrpt_matrix_type_nrows, \
00128                         MAT::mrpt_matrix_type_ncols>::mat_type
00129 
00130 
00131 
00132         /** TMatrixCovarianceType: Metaprogramming helper to determine the type of the MxM covariance matrix of an NxM matrix with samples in each row, in compile time.
00133           * This assume usage of DECLARE_MRPT_CONTAINER_IS_MATRIX and DECLARE_MRPT_CONTAINER_IS_MATRIX_FIXED.
00134           * Example of usage with the helper macro  MAT_TYPE_COVARIANCE_OF():
00135           *
00136           * \code
00137           *   void f(MAT1 m1) {
00138           *     MAT_TYPE_COVARIANCE_OF(MAT1) res = ...
00139           *     ...
00140           * \endcode
00141           */
00142         template <typename T,size_t NR1,size_t NC1>
00143         struct TMatrixCovarianceType // FIX -> FIX
00144         {
00145                 typedef CMatrixFixedNumeric<T,NC1,NC1> mat_type;
00146         };
00147 
00148         template <typename T>  // DYN -> DYN
00149         struct TMatrixCovarianceType<T,size_t(-1),size_t(-1)>
00150         {
00151                 typedef CMatrixTemplateNumeric<T> mat_type;
00152         };
00153 
00154         // Macro for easy usage of "TMatrixCovarianceType":
00155         // For use out of templates:
00156         #define MAT_TYPEDECL_COVARIANCE_OF(MAT) \
00157                 mrpt::math::detail::TMatrixCovarianceType< \
00158                         MAT::value_type, \
00159                         MAT::mrpt_matrix_type_nrows, \
00160                         MAT::mrpt_matrix_type_ncols>::mat_type
00161                         
00162         // For use within templates:
00163         #define MAT_TYPE_COVARIANCE_OF(MAT) \
00164                 typename mrpt::math::detail::TMatrixCovarianceType< \
00165                         typename MAT::value_type, \
00166                         MAT::mrpt_matrix_type_nrows, \
00167                         MAT::mrpt_matrix_type_ncols>::mat_type
00168 
00169 
00170         /** TMatrixJacobianType: Metaprogramming helper to determine the type of the MxN matrix from the types of two vector-like objects VECX (length N) and VECY (length M).
00171           * Example of usage with the helper macro  MAT_TYPE_JACOBIAN_OF():
00172           *
00173           * \code
00174           *   void f(VEC1 v1,VEC2 v2) {
00175           *     MAT_TYPE_JACOBIAN_OF(VEC1,VEC2) res = ...
00176           *     ...
00177           * \endcode
00178           */
00179         template <typename T,size_t N1,size_t N2>
00180         struct TMatrixJacobianType // In general -> Fix.
00181         {
00182                 typedef CMatrixFixedNumeric<T,N2,N1> mat_type;
00183         };
00184         template <typename T,size_t N1>  // One Dyn -> Dyn
00185         struct TMatrixJacobianType<T,N1,size_t(-1)>
00186         {
00187                 typedef CMatrixTemplateNumeric<T> mat_type;
00188         };
00189         template <typename T,size_t N2>  // One Dyn -> Dyn
00190         struct TMatrixJacobianType<T,size_t(-1),N2>
00191         {
00192                 typedef CMatrixTemplateNumeric<T> mat_type;
00193         };
00194         template <typename T>  // One Dyn -> Dyn
00195         struct TMatrixJacobianType<T,size_t(-1),size_t(-1)>
00196         {
00197                 typedef CMatrixTemplateNumeric<T> mat_type;
00198         };
00199         // Macro for easy usage of "TMatrixJacobianType":
00200         // For use out of templates:
00201         #define MAT_TYPEDECL_JACOBIAN_OF(VECX,VECY) \
00202                 mrpt::math::detail::TMatrixJacobianType< \
00203                         VECX::value_type, \
00204                         VECX::mrpt_vector_type_len, \
00205                         VECY::mrpt_vector_type_len>::mat_type
00206 
00207         // For use within templates:
00208         #define MAT_TYPE_JACOBIAN_OF(VECX,VECY) \
00209                 typename mrpt::math::detail::TMatrixJacobianType< \
00210                         typename VECX::value_type, \
00211                         VECX::mrpt_vector_type_len, \
00212                         VECY::mrpt_vector_type_len>::mat_type
00213 
00214         /** TMatrixSameSizeOfType: Metaprogramming helper to create a matrix of the same size that another type, in compile time.
00215           * This assume usage of DECLARE_MRPT_CONTAINER_IS_MATRIX and DECLARE_MRPT_CONTAINER_IS_MATRIX_FIXED.
00216           * Example of usage with the helper macro  MAT_TYPE_SAMESIZE_OF():
00217           *
00218           * \code
00219           *   void f(MAT1 m1) {
00220           *     MAT_TYPE_SAMESIZE_OF(MAT1) res = ...
00221           *     ...
00222           * \endcode
00223           */
00224         template <typename T,size_t NR1,size_t NC1>
00225         struct TMatrixSameSizeOfType // FIX -> FIX
00226         {
00227                 typedef CMatrixFixedNumeric<T,NR1,NC1> mat_type;
00228         };
00229 
00230         template <typename T>  // DYN -> DYN
00231         struct TMatrixSameSizeOfType<T,size_t(-1),size_t(-1)>
00232         {
00233                 typedef CMatrixTemplateNumeric<T> mat_type;
00234         };
00235 
00236         // Macro for easy usage of "TMatrixSameSizeOfType":
00237         // For use out of templates:
00238         #define MAT_TYPEDECL_SAMESIZE_OF(MAT) \
00239                 mrpt::math::detail::TMatrixSameSizeOfType< \
00240                         MAT::value_type, \
00241                         MAT::mrpt_matrix_type_nrows, \
00242                         MAT::mrpt_matrix_type_ncols>::mat_type
00243 
00244         // For use within templates:
00245         #define MAT_TYPE_SAMESIZE_OF(MAT) \
00246                 typename mrpt::math::detail::TMatrixSameSizeOfType< \
00247                         typename MAT::value_type, \
00248                         MAT::mrpt_matrix_type_nrows, \
00249                         MAT::mrpt_matrix_type_ncols>::mat_type
00250 
00251 
00252         /** TArrayOrVectorRowCountOfType: Metaprogramming helper to create a CArray or a std::vector<> with its size to the number of rows of a matrix, in compile time.
00253           * This assume usage of DECLARE_MRPT_CONTAINER, etc.
00254           * Example of usage with the helper macro ARRAY_TYPE_SAMESIZE_ROWS_OF():
00255           *
00256           * \code
00257           *   void f(MAT1 m1) {
00258           *     ARRAY_TYPE_SAMESIZE_ROWS_OF(MAT1) res = ...
00259           *     ...
00260           * \endcode
00261           */
00262         template <typename T,size_t NR1>
00263         struct TArrayOrVectorRowCountOfType // FIX -> CArray
00264         {
00265                 typedef CArrayNumeric<T,NR1> vec_type;
00266         };
00267 
00268         template <typename T>  // DYN -> std::vector<>
00269         struct TArrayOrVectorRowCountOfType<T,size_t(-1)>
00270         {
00271                 typedef std::vector<T> vec_type;
00272         };
00273 
00274         // Macro for easy usage of "TArrayOrVectorRowCountOfType":
00275         // For use out of templates:
00276         #define ARRAY_TYPEDECL_SAMESIZE_ROWS_OF(MAT) \
00277                 mrpt::math::detail::TArrayOrVectorRowCountOfType< \
00278                         MAT::value_type, \
00279                         MAT::mrpt_matrix_type_nrows>::vec_type
00280 
00281         // For use within templates:
00282         #define ARRAY_TYPE_SAMESIZE_ROWS_OF(MAT) \
00283                 typename mrpt::math::detail::TArrayOrVectorRowCountOfType< \
00284                         typename MAT::value_type, \
00285                         MAT::mrpt_matrix_type_nrows>::vec_type
00286 
00287 
00288         /** @} */
00289 }}} // end namespaces
00290 
00291 #endif