ViennaCL - The Vienna Computing Library  1.5.0
viennacl/scheduler/execute_matrix_dispatcher.hpp
Go to the documentation of this file.
00001 #ifndef VIENNACL_SCHEDULER_EXECUTE_MATRIX_DISPATCHER_HPP
00002 #define VIENNACL_SCHEDULER_EXECUTE_MATRIX_DISPATCHER_HPP
00003 
00004 /* =========================================================================
00005    Copyright (c) 2010-2013, Institute for Microelectronics,
00006                             Institute for Analysis and Scientific Computing,
00007                             TU Wien.
00008    Portions of this software are copyright by UChicago Argonne, LLC.
00009 
00010                             -----------------
00011                   ViennaCL - The Vienna Computing Library
00012                             -----------------
00013 
00014    Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at
00015 
00016    (A list of authors and contributors can be found in the PDF manual)
00017 
00018    License:         MIT (X11), see file LICENSE in the base directory
00019 ============================================================================= */
00020 
00021 
00026 #include <assert.h>
00027 
00028 #include "viennacl/forwards.h"
00029 #include "viennacl/scheduler/forwards.h"
00030 #include "viennacl/scheduler/execute_util.hpp"
00031 #include "viennacl/linalg/matrix_operations.hpp"
00032 
00033 namespace viennacl
00034 {
00035   namespace scheduler
00036   {
00037     namespace detail
00038     {
00039 
00041       template <typename ScalarType1>
00042       void am(lhs_rhs_element & mat1,
00043               lhs_rhs_element const & mat2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
00044       {
00045         assert(   mat1.type_family == MATRIX_TYPE_FAMILY && mat2.type_family == MATRIX_TYPE_FAMILY
00046                && bool("Arguments are not matrix types!"));
00047 
00048         assert(mat1.numeric_type == mat2.numeric_type && bool("Matrices do not have the same scalar type"));
00049 
00050         if (mat1.subtype == DENSE_ROW_MATRIX_TYPE)
00051         {
00052           switch (mat1.numeric_type)
00053           {
00054           case FLOAT_TYPE:
00055             viennacl::linalg::am(*mat1.matrix_row_float,
00056                                  *mat2.matrix_row_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha);
00057             break;
00058           case DOUBLE_TYPE:
00059             viennacl::linalg::am(*mat1.matrix_row_double,
00060                                  *mat2.matrix_row_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha);
00061             break;
00062 
00063           default:
00064             throw statement_not_supported_exception("Invalid arguments in scheduler when calling am()");
00065           }
00066         }
00067         else if (mat1.subtype == DENSE_COL_MATRIX_TYPE)
00068         {
00069           switch (mat1.numeric_type)
00070           {
00071           case FLOAT_TYPE:
00072             viennacl::linalg::am(*mat1.matrix_col_float,
00073                                  *mat2.matrix_col_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha);
00074             break;
00075           case DOUBLE_TYPE:
00076             viennacl::linalg::am(*mat1.matrix_col_double,
00077                                  *mat2.matrix_col_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha);
00078             break;
00079 
00080           default:
00081             throw statement_not_supported_exception("Invalid arguments in scheduler when calling am()");
00082           }
00083         }
00084         else
00085         {
00086           throw statement_not_supported_exception("Invalid arguments in scheduler when calling am()");
00087         }
00088       }
00089 
00091       template <typename ScalarType1, typename ScalarType2>
00092       void ambm(lhs_rhs_element & mat1,
00093                 lhs_rhs_element const & mat2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
00094                 lhs_rhs_element const & mat3, ScalarType2 const & beta,  vcl_size_t len_beta,  bool reciprocal_beta,  bool flip_sign_beta)
00095       {
00096         assert(   mat1.type_family == MATRIX_TYPE_FAMILY
00097                && mat2.type_family == MATRIX_TYPE_FAMILY
00098                && mat3.type_family == MATRIX_TYPE_FAMILY
00099                && bool("Arguments are not matrix types!"));
00100 
00101         assert(   (mat1.subtype == mat2.subtype)
00102                && (mat2.subtype == mat3.subtype)
00103                && bool("Matrices do not have the same layout"));
00104 
00105         assert(   (mat1.numeric_type == mat2.numeric_type)
00106                && (mat2.numeric_type == mat3.numeric_type)
00107                && bool("Matrices do not have the same scalar type"));
00108 
00109         if (mat1.subtype == DENSE_ROW_MATRIX_TYPE)
00110         {
00111           switch (mat1.numeric_type)
00112           {
00113           case FLOAT_TYPE:
00114             viennacl::linalg::ambm(*mat1.matrix_row_float,
00115                                    *mat2.matrix_row_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00116                                    *mat3.matrix_row_float, convert_to_float(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00117             break;
00118           case DOUBLE_TYPE:
00119             viennacl::linalg::ambm(*mat1.matrix_row_double,
00120                                    *mat2.matrix_row_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00121                                    *mat3.matrix_row_double, convert_to_double(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00122             break;
00123           default:
00124             throw statement_not_supported_exception("Invalid arguments in scheduler when calling ambm()");
00125           }
00126         }
00127         else if (mat1.subtype == DENSE_COL_MATRIX_TYPE)
00128         {
00129           switch (mat1.numeric_type)
00130           {
00131           case FLOAT_TYPE:
00132             viennacl::linalg::ambm(*mat1.matrix_col_float,
00133                                    *mat2.matrix_col_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00134                                    *mat3.matrix_col_float, convert_to_float(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00135             break;
00136           case DOUBLE_TYPE:
00137             viennacl::linalg::ambm(*mat1.matrix_col_double,
00138                                    *mat2.matrix_col_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00139                                    *mat3.matrix_col_double, convert_to_double(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00140             break;
00141           default:
00142             throw statement_not_supported_exception("Invalid arguments in scheduler when calling ambm()");
00143           }
00144         }
00145       }
00146 
00148       template <typename ScalarType1, typename ScalarType2>
00149       void ambm_m(lhs_rhs_element & mat1,
00150                   lhs_rhs_element const & mat2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
00151                   lhs_rhs_element const & mat3, ScalarType2 const & beta,  vcl_size_t len_beta,  bool reciprocal_beta,  bool flip_sign_beta)
00152       {
00153         assert(   mat1.type_family == MATRIX_TYPE_FAMILY
00154                && mat2.type_family == MATRIX_TYPE_FAMILY
00155                && mat3.type_family == MATRIX_TYPE_FAMILY
00156                && bool("Arguments are not matrix types!"));
00157 
00158         assert(   (mat1.subtype == mat2.subtype)
00159                && (mat2.subtype == mat3.subtype)
00160                && bool("Matrices do not have the same layout"));
00161 
00162         assert(   (mat1.numeric_type == mat2.numeric_type)
00163                && (mat2.numeric_type == mat3.numeric_type)
00164                && bool("Matrices do not have the same scalar type"));
00165 
00166         if (mat1.subtype == DENSE_ROW_MATRIX_TYPE)
00167         {
00168           switch (mat1.numeric_type)
00169           {
00170           case FLOAT_TYPE:
00171             viennacl::linalg::ambm_m(*mat1.matrix_row_float,
00172                                      *mat2.matrix_row_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00173                                      *mat3.matrix_row_float, convert_to_float(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00174             break;
00175           case DOUBLE_TYPE:
00176             viennacl::linalg::ambm_m(*mat1.matrix_row_double,
00177                                      *mat2.matrix_row_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00178                                      *mat3.matrix_row_double, convert_to_double(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00179             break;
00180           default:
00181             throw statement_not_supported_exception("Invalid arguments in scheduler when calling ambm_m()");
00182           }
00183         }
00184         else if (mat1.subtype == DENSE_COL_MATRIX_TYPE)
00185         {
00186           switch (mat1.numeric_type)
00187           {
00188           case FLOAT_TYPE:
00189             viennacl::linalg::ambm_m(*mat1.matrix_col_float,
00190                                      *mat2.matrix_col_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00191                                      *mat3.matrix_col_float, convert_to_float(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00192             break;
00193           case DOUBLE_TYPE:
00194             viennacl::linalg::ambm_m(*mat1.matrix_col_double,
00195                                      *mat2.matrix_col_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha,
00196                                      *mat3.matrix_col_double, convert_to_double(beta),  len_beta,  reciprocal_beta,  flip_sign_beta);
00197             break;
00198           default:
00199             throw statement_not_supported_exception("Invalid arguments in scheduler when calling ambm_m()");
00200           }
00201         }
00202       }
00203 
00204 
00205     } // namespace detail
00206   } // namespace scheduler
00207 } // namespace viennacl
00208 
00209 #endif
00210