vectorops.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_VECTOROPS_H
#define PARGEMSLR_VECTOROPS_H
 
#include <vector>
 
#include "../utils/utils.hpp"
#include "vector.hpp"
#include "int_vector.hpp"
#include "sequential_vector.hpp"
#include "parallel_vector.hpp"
 
using namespace std;
 
namespace pargemslr
{
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<int> &vec);
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<long int> &vec);
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<float> &vec);
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<double> &vec);
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<complexs> &vec);
   
   PrecisionEnum GetVectorPrecision(const VectorVirtualClass<complexd> &vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<int> *vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<long int> *vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<float> *vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<double> *vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<complexs> *vec);
   
   PrecisionEnum GetVectorPPrecision(const VectorVirtualClass<complexd> *vec);
   
#ifdef PARGEMSLR_CUDA
 
   int VectorRandDevice( VectorClass<float> &x);
   
   int VectorRandDevice( VectorClass<double> &x);
   
   int VectorRandDevice( VectorClass<complexs> &x);
   
   int VectorRandDevice( VectorClass<complexd> &x);
 
#endif
   
   
   template <typename T>
   int VectorPDotTemplate( int n, const T *x, const T *y, T &t );
   
   int VectorDot( const vector_base_float &x, const vector_base_float &y, float &t);
   
   int VectorDot( const vector_base_double &x, const vector_base_double &y, double &t);
   
   int VectorDot( const vector_base_complexs &x, const vector_base_complexs &y, complexs &t);
   
   int VectorDot( const vector_base_complexd &x, const vector_base_complexd &y, complexd &t);
 
#ifdef PARGEMSLR_CUDA 
   
   int VectorSdotDevice( const vector_base_float &x, const vector_base_float &y, float &t);
   
   int VectorDdotDevice( const vector_base_double &x, const vector_base_double &y, double &t);
   
   int VectorCdotDevice( const vector_base_complexs &x, const vector_base_complexs &y, complexs &t);
   
   int VectorZdotDevice( const vector_base_complexd &x, const vector_base_complexd &y, complexd &t);
   
#endif
   
   template <typename T>
   int VectorPScaleTemplate( int n, T *x, const T&a);
   
   int VectorScale(VectorClass<float> &x, const float &a);
   
   int VectorScale(VectorClass<double> &x, const double &a);
   
   int VectorScale(VectorClass<complexs> &x, const complexs &a);
   
   int VectorScale(VectorClass<complexd> &x, const complexd &a);
   
#ifdef PARGEMSLR_CUDA
   
   int VectorSscaleDevice(VectorClass<float> &x, const float &a);
   
   int VectorDscaleDevice(VectorClass<double> &x, const double &a);
   
   int VectorCscaleDevice(VectorClass<complexs> &x, const complexs &a);
   
   int VectorZscaleDevice(VectorClass<complexd> &x, const complexd &a);
   
#endif
   
   template <typename T>
   int VectorPAxpyTemplate( int n, const T &a, const T *x, T *y);
   
   int VectorAxpy( const float &a, const VectorClass<float> &x, VectorClass<float> &y);
   
   int VectorAxpy( const double &a, const VectorClass<double> &x, VectorClass<double> &y);
   
   int VectorAxpy( const complexs &a, const VectorClass<complexs> &x, VectorClass<complexs> &y);
   
   int VectorAxpy( const complexd &a, const VectorClass<complexd> &x, VectorClass<complexd> &y);
   
#ifdef PARGEMSLR_CUDA 
   
   int VectorSaxpyDevice( const float &a, const VectorClass<float> &x, VectorClass<float> &y);
   
   int VectorDaxpyDevice( const double &a, const VectorClass<double> &x, VectorClass<double> &y);
   
   int VectorCaxpyDevice( const complexs &a, const VectorClass<complexs> &x, VectorClass<complexs> &y);
   
   int VectorZaxpyDevice( const complexd &a, const VectorClass<complexd> &x, VectorClass<complexd> &y);
 
   int SequentialVectorCreateCusparseDnVec(vector_seq_float &v);
   
   int SequentialVectorCreateCusparseDnVec(vector_seq_double &v);
   
   int SequentialVectorCreateCusparseDnVec(vector_seq_complexs &v);
   
   int SequentialVectorCreateCusparseDnVec(vector_seq_complexd &v);
 
#endif
   
   template <typename T>
   int VectorPBsearchHost(const T *v, const T &val, int s, int e, int &idx, bool ascending);
   
   template <typename T>
   int VectorPlotHost( const VectorVirtualClass<T> &x, int conditiona, int conditionb, int width);
   
   int SequentialVectorReadFromFile(SequentialVectorClass<float> &vec, const char *vecfile, int idxin);
   
   int SequentialVectorReadFromFile(SequentialVectorClass<double> &vec, const char *vecfile, int idxin);
   
   int SequentialVectorReadFromFile(SequentialVectorClass<complexs> &vec, const char *vecfile, int idxin);
   
   int SequentialVectorReadFromFile(SequentialVectorClass<complexd> &vec, const char *vecfile, int idxin);
   
   template <typename T1, typename T2>
   int VectorCopy(VectorClass<T1> &vec_in, VectorClass<T2> &vec2_out);
   
}
 
#endif