All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
predicate.hpp
Go to the documentation of this file.
#ifndef VIENNACL_META_PREDICATE_HPP_
#define VIENNACL_META_PREDICATE_HPP_
/* =========================================================================
Copyright (c) 2010-2016, Institute for Microelectronics,
Institute for Analysis and Scientific Computing,
TU Wien.
Portions of this software are copyright by UChicago Argonne, LLC.
-----------------
ViennaCL - The Vienna Computing Library
-----------------
Project Head: Karl Rupp rupp@iue.tuwien.ac.at
(A list of authors and contributors can be found in the manual)
License: MIT (X11), see file LICENSE in the base directory
============================================================================= */
#include <string>
#include <fstream>
#include <sstream>
#include "viennacl/forwards.h"
#ifdef VIENNACL_WITH_OPENCL
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include "CL/cl.h"
#endif
#endif
namespace viennacl
{
//
// is_cpu_scalar: checks for float or double
//
//template<typename T>
//struct is_cpu_scalar
//{
// enum { value = false };
//};
template<> struct is_cpu_scalar<char> { enum { value = true }; };
template<> struct is_cpu_scalar<unsigned char> { enum { value = true }; };
template<> struct is_cpu_scalar<short> { enum { value = true }; };
template<> struct is_cpu_scalar<unsigned short> { enum { value = true }; };
template<> struct is_cpu_scalar<int> { enum { value = true }; };
template<> struct is_cpu_scalar<unsigned int> { enum { value = true }; };
template<> struct is_cpu_scalar<long> { enum { value = true }; };
template<> struct is_cpu_scalar<unsigned long> { enum { value = true }; };
template<> struct is_cpu_scalar<float> { enum { value = true }; };
template<> struct is_cpu_scalar<double> { enum { value = true }; };
//
// is_scalar: checks for viennacl::scalar
//
//template<typename T>
//struct is_scalar
//{
// enum { value = false };
//};
template<typename T>
struct is_scalar<viennacl::scalar<T> >
{
enum { value = true };
};
//
// is_flip_sign_scalar: checks for viennacl::scalar modified with unary operator-
//
//template<typename T>
//struct is_flip_sign_scalar
//{
// enum { value = false };
//};
template<typename T>
struct is_flip_sign_scalar<viennacl::scalar_expression< const scalar<T>,
const scalar<T>,
op_flip_sign> >
{
enum { value = true };
};
//
// is_any_scalar: checks for either CPU and GPU scalars, i.e. is_cpu_scalar<>::value || is_scalar<>::value
//
//template<typename T>
//struct is_any_scalar
//{
// enum { value = (is_scalar<T>::value || is_cpu_scalar<T>::value || is_flip_sign_scalar<T>::value )};
//};
//
#define VIENNACL_MAKE_ANY_VECTOR_TRUE(type) template<> struct is_any_vector< type > { enum { value = 1 }; };
#define VIENNACL_MAKE_FOR_ALL_NumericT(type) \
VIENNACL_MAKE_ANY_VECTOR_TRUE(type<float>)\
VIENNACL_MAKE_ANY_VECTOR_TRUE(type<double>)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::vector)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::vector_range)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::vector_slice)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::unit_vector)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::zero_vector)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::one_vector)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::scalar_vector)
#undef VIENNACL_MAKE_FOR_ALL_NumericT
#undef VIENNACL_MAKE_ANY_VECTOR_TRUE
#define VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE)\
template<> struct is_any_dense_matrix< TYPE > { enum { value = 1 }; };
#define VIENNACL_MAKE_FOR_ALL_NumericT(TYPE) \
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<float>)\
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<double>)
#define VIENNACL_COMMA ,
#define VIENNACL_MAKE_FOR_ALL_NumericT_LAYOUT(TYPE) \
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<float VIENNACL_COMMA viennacl::row_major>)\
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<double VIENNACL_COMMA viennacl::row_major>)\
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<float VIENNACL_COMMA viennacl::column_major>)\
VIENNACL_MAKE_ANY_MATRIX_TRUE(TYPE<double VIENNACL_COMMA viennacl::column_major>)
VIENNACL_MAKE_FOR_ALL_NumericT_LAYOUT(viennacl::matrix)
// VIENNACL_MAKE_FOR_ALL_NumericT_LAYOUT(viennacl::matrix_range)
// VIENNACL_MAKE_FOR_ALL_NumericT_LAYOUT(viennacl::matrix_slice)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::identity_matrix)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::zero_matrix)
VIENNACL_MAKE_FOR_ALL_NumericT(viennacl::scalar_matrix)
#undef VIENNACL_MAKE_FOR_ALL_NumericT_LAYOUT
#undef VIENNACL_MAKE_FOR_ALL_NumericT
#undef VIENNACL_MAKE_ANY_MATRIX_TRUE
#undef VIENNACL_COMMA
//
// is_row_major
//
//template<typename T>
//struct is_row_major
//{
// enum { value = false };
//};
template<typename ScalarType>
struct is_row_major<viennacl::matrix<ScalarType, viennacl::row_major> >
{
enum { value = true };
};
template<>
struct is_row_major< viennacl::row_major >
{
enum { value = true };
};
template<typename T>
struct is_row_major<viennacl::matrix_expression<T, T, viennacl::op_trans> >
{
enum { value = is_row_major<T>::value };
};
//
// is_circulant_matrix
//
//template<typename T>
//struct is_circulant_matrix
//{
// enum { value = false };
//};
template<typename ScalarType, unsigned int AlignmentV>
struct is_circulant_matrix<viennacl::circulant_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_circulant_matrix<const viennacl::circulant_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_hankel_matrix
//
//template<typename T>
//struct is_hankel_matrix
//{
// enum { value = false };
//};
template<typename ScalarType, unsigned int AlignmentV>
struct is_hankel_matrix<viennacl::hankel_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_hankel_matrix<const viennacl::hankel_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_toeplitz_matrix
//
//template<typename T>
//struct is_toeplitz_matrix
//{
// enum { value = false };
//};
template<typename ScalarType, unsigned int AlignmentV>
struct is_toeplitz_matrix<viennacl::toeplitz_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_toeplitz_matrix<const viennacl::toeplitz_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_vandermonde_matrix
//
//template<typename T>
//struct is_vandermonde_matrix
//{
// enum { value = false };
//};
template<typename ScalarType, unsigned int AlignmentV>
struct is_vandermonde_matrix<viennacl::vandermonde_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_vandermonde_matrix<const viennacl::vandermonde_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_compressed_matrix
//
template<typename ScalarType, unsigned int AlignmentV>
struct is_compressed_matrix<viennacl::compressed_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_coordinate_matrix
//
template<typename ScalarType, unsigned int AlignmentV>
struct is_coordinate_matrix<viennacl::coordinate_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_ell_matrix
//
template<typename ScalarType, unsigned int AlignmentV>
struct is_ell_matrix<viennacl::ell_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_sliced_ell_matrix
//
template<typename ScalarType, typename IndexT>
struct is_sliced_ell_matrix<viennacl::sliced_ell_matrix<ScalarType, IndexT> >
{
enum { value = true };
};
//
// is_hyb_matrix
//
template<typename ScalarType, unsigned int AlignmentV>
struct is_hyb_matrix<viennacl::hyb_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
//
// is_any_sparse_matrix
//
//template<typename T>
//struct is_any_sparse_matrix
//{
// enum { value = false };
//};
template<typename ScalarType, unsigned int AlignmentV>
struct is_any_sparse_matrix<viennacl::compressed_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType>
struct is_any_sparse_matrix<viennacl::compressed_compressed_matrix<ScalarType> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_any_sparse_matrix<viennacl::coordinate_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_any_sparse_matrix<viennacl::ell_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename ScalarType, typename IndexT>
struct is_any_sparse_matrix<viennacl::sliced_ell_matrix<ScalarType, IndexT> >
{
enum { value = true };
};
template<typename ScalarType, unsigned int AlignmentV>
struct is_any_sparse_matrix<viennacl::hyb_matrix<ScalarType, AlignmentV> >
{
enum { value = true };
};
template<typename T>
struct is_any_sparse_matrix<const T>
{
enum { value = is_any_sparse_matrix<T>::value };
};
//
// is_addition
//
template<typename T>
struct is_addition
{
enum { value = false };
};
template<>
struct is_addition<viennacl::op_add>
{
enum { value = true };
};
//
// is_subtraction
//
template<typename T>
struct is_subtraction
{
enum { value = false };
};
template<>
struct is_subtraction<viennacl::op_sub>
{
enum { value = true };
};
//
// is_product
//
template<typename T>
struct is_product
{
enum { value = false };
};
template<>
struct is_product<viennacl::op_prod>
{
enum { value = true };
};
template<>
struct is_product<viennacl::op_mult>
{
enum { value = true };
};
template<>
struct is_product<viennacl::op_element_binary<op_prod> >
{
enum { value = true };
};
//
// is_division
//
template<typename T>
struct is_division
{
enum { value = false };
};
template<>
struct is_division<viennacl::op_div>
{
enum { value = true };
};
template<>
struct is_division<viennacl::op_element_binary<op_div> >
{
enum { value = true };
};
// is_primitive_type
//
template<class T>
struct is_primitive_type{ enum {value = false}; };
template<> struct is_primitive_type<float> { enum { value = true }; };
template<> struct is_primitive_type<double> { enum { value = true }; };
template<> struct is_primitive_type<unsigned int> { enum { value = true }; };
template<> struct is_primitive_type<int> { enum { value = true }; };
template<> struct is_primitive_type<unsigned char> { enum { value = true }; };
template<> struct is_primitive_type<char> { enum { value = true }; };
template<> struct is_primitive_type<unsigned long> { enum { value = true }; };
template<> struct is_primitive_type<long> { enum { value = true }; };
template<> struct is_primitive_type<unsigned short>{ enum { value = true }; };
template<> struct is_primitive_type<short> { enum { value = true }; };
#ifdef VIENNACL_WITH_OPENCL
template<class T>
struct is_cl_type{ enum { value = false }; };
template<> struct is_cl_type<cl_float> { enum { value = true }; };
template<> struct is_cl_type<cl_double>{ enum { value = true }; };
template<> struct is_cl_type<cl_uint> { enum { value = true }; };
template<> struct is_cl_type<cl_int> { enum { value = true }; };
template<> struct is_cl_type<cl_uchar> { enum { value = true }; };
template<> struct is_cl_type<cl_char> { enum { value = true }; };
template<> struct is_cl_type<cl_ulong> { enum { value = true }; };
template<> struct is_cl_type<cl_long> { enum { value = true }; };
template<> struct is_cl_type<cl_ushort>{ enum { value = true }; };
template<> struct is_cl_type<cl_short> { enum { value = true }; };
template<class T> struct is_floating_point { enum { value = false }; };
template<> struct is_floating_point<float> { enum { value = true }; };
template<> struct is_floating_point<double> { enum { value = true }; };
#endif
} //namespace viennacl
#endif
viennacl::is_compressed_matrix::value
Definition: forwards.h:493
viennacl::is_row_major::value
Definition: forwards.h:486
viennacl::is_flip_sign_scalar::value
Definition: forwards.h:464
viennacl::is_coordinate_matrix::value
Definition: forwards.h:500
viennacl::is_ell_matrix::value
Definition: forwards.h:507
viennacl::is_sliced_ell_matrix::value
Definition: forwards.h:514
viennacl::is_primitive_type
Helper class for checking whether a type is a primitive type.
Definition: predicate.hpp:490
viennacl::is_circulant_matrix::value
Definition: forwards.h:537
forwards.h
This file provides the forward declarations for the main types used within ViennaCL.
viennacl::is_subtraction
Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction) ...
Definition: predicate.hpp:418
viennacl::matrix
A dense matrix class.
Definition: forwards.h:375
viennacl::is_toeplitz_matrix::value
Definition: forwards.h:551
viennacl::is_hankel_matrix::value
Definition: forwards.h:544
viennacl::is_cpu_scalar::value
Definition: forwards.h:450
viennacl::vector
Definition: forwards.h:266
viennacl::is_division
Helper metafunction for checking whether the provided type is viennacl::op_div (for division) ...
Definition: predicate.hpp:466
viennacl::is_any_sparse_matrix::value
Definition: forwards.h:529
viennacl::is_addition::value
Definition: predicate.hpp:402
viennacl::is_addition
Helper metafunction for checking whether the provided type is viennacl::op_add (for addition) ...
Definition: predicate.hpp:400
viennacl::traits::row_major
bool row_major(T const &)
Definition: row_major.hpp:38
viennacl::is_scalar::value
Definition: forwards.h:457
viennacl::is_subtraction::value
Definition: predicate.hpp:420
viennacl::is_hyb_matrix::value
Definition: forwards.h:522
viennacl::is_division::value
Definition: predicate.hpp:468
viennacl::is_primitive_type::value
Definition: predicate.hpp:490
viennacl::is_product
Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multipl...
Definition: predicate.hpp:436
viennacl::is_vandermonde_matrix::value
Definition: forwards.h:558
viennacl::is_product::value
Definition: predicate.hpp:438