vector.h

Go to the documentation of this file.

#ifndef G_LD1RHWBBXD615K1PEKWNYBSHDF5Q8
#define G_LD1RHWBBXD615K1PEKWNYBSHDF5Q8

#include <stddef.h>
#include "extern.h"
#include "inline_begin.h"
#include "restrict_begin.h"
#ifdef __cplusplus
extern "C" {
#endif

typedef void SgVector;

typedef void SgVectorAccum;

typedef int SgVectorAccumType;

typedef void SgVectorOperation(void *f_ctx,
                               SgVectorAccum *accum,
                               const SgVectorAccum *val,
                               size_t offset,
                               double **data,
                               size_t num_elems);

typedef void SgVectorDriverBase;

struct SgVectorDriverVt {
    size_t (*len)(const SgVectorDriverBase *self);

    SgVector *(*try_new)(const SgVectorDriverBase *self);

    void (*del)(const SgVectorDriverBase *self, SgVector *vector);

    void (*operate)(const SgVectorDriverBase *self,
                    SgVectorAccum *accum,
                    SgVectorAccumType accum_type,
                    SgVectorOperation *f,
                    void *f_ctx,
                    size_t offset,
                    SgVector **vectors,
                    size_t num_vectors);
};

struct SgVectorDriver {
    const SgVectorDriverBase *data;
    const struct SgVectorDriverVt *vtable;
};

SG_EXTERN SgVector *sg_vector_try_new(struct SgVectorDriver drv);

SG_EXTERN SgVector *sg_vector_new(struct SgVectorDriver drv);

SG_EXTERN void sg_vector_del(struct SgVectorDriver drv, SgVector *vector);

SG_EXTERN size_t sg_vector_len(struct SgVectorDriver drv);

SG_EXTERN void sg_vector_operate(struct SgVectorDriver drv,
                                 SgVectorAccum *accum,
                                 SgVectorAccumType accum_type,
                                 SgVectorOperation *f,
                                 void *f_ctx,
                                 size_t offset,
                                 SgVector **vectors,
                                 size_t num_vectors);

SG_EXTERN void sg_vector_fill(struct SgVectorDriver drv,
                              double value,
                              SgVector *vector);

SG_EXTERN extern SgVectorOperation sg_vector_fill_operation;

SG_EXTERN void sg_vector_copy(struct SgVectorDriver drv,
                              const SgVector *src,
                              SgVector *dest);

SG_EXTERN extern SgVectorOperation sg_vector_copy_operation;

SG_EXTERN void sg_vector_neg_assign(struct SgVectorDriver drv, SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_neg_assign_operation;

SG_EXTERN void sg_vector_neg(struct SgVectorDriver drv,
                             const SgVector *x,
                             SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_neg_operation;

SG_EXTERN void sg_vector_scale_assign(struct SgVectorDriver drv,
                            double alpha,
                            SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_scale_assign_operation;

SG_EXTERN void sg_vector_scale(struct SgVectorDriver drv,
                               double alpha,
                               const SgVector *x,
                               SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_scale_operation;

SG_EXTERN void sg_vector_linear_assign(struct SgVectorDriver drv,
                                       double alpha,
                                       double beta,
                                       const SgVector *y,
                                       SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_linear_assign_operation;

SG_EXTERN void sg_vector_linear(struct SgVectorDriver drv,
                                double alpha,
                                const SgVector *x,
                                double beta,
                                const SgVector *y,
                                SgVector *z);

SG_EXTERN extern SgVectorOperation sg_vector_linear_operation;

SG_EXTERN double sg_vector_sum(struct SgVectorDriver drv,
                               const SgVector *vector);

SG_EXTERN extern SgVectorOperation sg_vector_sum_operation;

SG_EXTERN extern struct SgVectorDriverVt SG_BASIC_VECTOR_DRIVER_VT;

static inline struct SgVectorDriver sg_basic_vector_driver(size_t *len)
{
    struct SgVectorDriver drv;
    drv.data = len;
    drv.vtable = &SG_BASIC_VECTOR_DRIVER_VT;
    return drv;
}

#ifdef __cplusplus
}
#endif
#include "restrict_end.h"
#include "inline_end.h"
#endif