index.h (2014-04-30 15:38:09 -0400, (build fd32605))

Go to the documentation of this file.

//-----------------------------------------------------------------------//
//   Copyright (c) AccelerEyes LLC. All rights reserved.                 //
//   See http://www.accelereyes.com/eula for details.                    //
//   This software is distributed WITHOUT ANY WARRANTY; without even     //
//   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
//   PURPOSE.  See the above copyright notices for more information.     //
//-----------------------------------------------------------------------//

#pragma once
#include "defines.h"

#define is_gpu(id) ((id) == S_GPU || (id) == S_IRITH_SCALAR || (id) == S_IRITH_MATRIX)

enum stype_t {
    S_LIN, 
    S_NON, 
    S_GPU, 
    S_I,   
    S_IRITH_SCALAR, 
    S_IRITH_MATRIX, 
};
enum sty_t {
    STY_BOOL, 
    STY_F32,  
    STY_F64,  
    STY_U32,  
};

typedef struct {
    enum stype_t type; 
    union {
        struct { int first, inc; } lin; 
        struct { unsigned pos; } non; 
        struct {
            sty_t ty; 
            int id; 
        } gpu; 
    } d;
} sub_t;

#ifdef __cplusplus
#include "exception.h"

namespace af {

class AFAPI seq
{
    public:
    double first;   
    double inc;     
    double last;    
    unsigned size;  

    seq();

    explicit seq(double n);

    seq(double first, double last);

    seq(double first, double inc, double last);

    inline seq operator-()         { return seq(-first, -inc,  -last); }

    inline seq operator+(double x) { return seq(first+x, inc,   last+x); }

    inline seq operator-(double x) { return seq(first-x, inc,   last-x); }

    inline seq operator*(double x) { return seq(first*x, inc*x, last*x); }

    friend inline seq operator+(double x, seq y) { return  y + x; }

    friend inline seq operator-(double x, seq y) { return -y + x; }

    friend inline seq operator*(double x, seq y) { return  y * x; }

    private:
    void init(double first, double inc, double last);
};
extern AFAPI int end;
extern AFAPI seq span;
} // namespace af
#endif // __cplusplus

#define _B_  bool
#define _S_  float
#define _D_  double
#define _C_  cfloat
#define _Z_  cdouble
#define _I_  int
#define _U_  unsigned

#define JI_PARAMS                                                    \
    int nsubs, const sub_t *subs,                                       \
        const unsigned *dims_dst, const unsigned *dims_src, unsigned base, \
        const unsigned *inds, const void *d0, const void *d1, const void *d2, \
        unsigned ngfor_dst, unsigned ngfor_sub, float start, float inc

#define GET(T)        AFAPI afError af_get(_##T##_ *d_dst, const _##T##_ *d_src, JI_PARAMS);
#define SET(T)        AFAPI afError af_set(_##T##_ *d_dst, const _##T##_ *d_src, JI_PARAMS, unsigned ngfor_src);
#define SETSCALAR(T)                                                    \
    AFAPI afError af_setscalar(_##T##_ *d_dst, const _##T##_ src, JI_PARAMS); \
    AFAPI afError af_setscalar(_##T##_ *d_dst, const _##T##_ *d_src, JI_PARAMS, unsigned ngfor_src);



// inputs:
// - inds -- zero-indexed values
// - d* -- zero-indexed values in device memory (float or bool)
// - lin.first -- zero-indexed

GET(B)
GET(S) GET(D)
GET(C) GET(Z)
GET(U) GET(I)
#undef GET

SET(B)
SET(S) SET(D)
SET(C) SET(Z)
SET(U) SET(I)
#undef SET

SETSCALAR(B)
SETSCALAR(S) SETSCALAR(D)
SETSCALAR(C) SETSCALAR(Z)
SETSCALAR(U) SETSCALAR(I)
#undef SETSCALAR


#undef JI_PARAMS

AFAPI afError  af_remove_SS(float *d_out,
                     unsigned num_in, float *d_in,
                     unsigned num_rm, float *h_idx);

AFAPI afError  af_remove_DS(double *d_out,
                     unsigned num_in, double *d_in,
                     unsigned num_rm, float *h_idx);

AFAPI afError  af_remove_CS(cfloat *d_out,
                     unsigned num_in, cfloat *d_in,
                     unsigned num_rm, float *h_idx);

AFAPI afError  af_remove_ZS(cdouble *d_out,
                     unsigned num_in, cdouble *d_in,
                     unsigned num_rm, float *h_idx);

AFAPI afError  af_remove_DD(double *d_out,
                     unsigned num_in, double *d_in,
                     unsigned num_rm, double *h_idx);

AFAPI afError  af_remove_ZD(cdouble *d_out,
                     unsigned num_in, cdouble *d_in,
                     unsigned num_rm, double *h_idx);

AFAPI afError  af_remove_SU(float *d_out,
                     unsigned num_in, float *d_in,
                     unsigned num_rm, unsigned *h_idx);

AFAPI afError  af_remove_DU(double *d_out,
                     unsigned num_in, double *d_in,
                     unsigned num_rm, unsigned *h_idx);

AFAPI afError  af_remove_CU(cfloat *d_out,
                     unsigned num_in, cfloat *d_in,
                     unsigned num_rm, unsigned *h_idx);

AFAPI afError  af_remove_ZU(cdouble *d_out,
                     unsigned num_in, cdouble *d_in,
                     unsigned num_rm, unsigned *h_idx);

//

AFAPI afError  af_range_S(float *d_out,
                          float start, float step,
                          unsigned numel);