Mutils.h

Go to the documentation of this file.

#ifndef MATRIX_MUTILS_H
#define MATRIX_MUTILS_H

#undef Matrix_with_SPQR

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h> // C99 for int64_t
#include <ctype.h>
#include <R.h>  /* includes Rconfig.h */
#include <Rversion.h>
#include <Rdefines.h> /* Rinternals.h + GET_SLOT etc */

#ifdef ENABLE_NLS
#include <libintl.h>
#define _(String) dgettext ("Matrix", String)
#else
#define _(String) (String)
/* Note that this is not yet supported (for Windows, e.g.) in R 2.9.0 : */
#define dngettext(pkg, String, StringP, N) (N > 1 ? StringP : String)
#endif

#ifdef __GNUC__
# undef alloca
# define alloca(x) __builtin_alloca((x))
#elif defined(__sun) || defined(_AIX)
/* this is necessary (and sufficient) for Solaris 10 and AIX 6: */
# include <alloca.h>
#endif

#define Alloca(n, t)   (t *) alloca( (size_t) ( (n) * sizeof(t) ) )

SEXP triangularMatrix_validate(SEXP obj);
SEXP symmetricMatrix_validate(SEXP obj);
SEXP dense_nonpacked_validate(SEXP obj);

/* enum constants from cblas.h and some short forms */
enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102};
enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113};
enum CBLAS_UPLO {CblasUpper=121, CblasLower=122};
enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132};
enum CBLAS_SIDE {CblasLeft=141, CblasRight=142};
#define RMJ CblasRowMajor
#define CMJ CblasColMajor
#define NTR CblasNoTrans
#define TRN CblasTrans
#define CTR CblasConjTrans
#define UPP CblasUpper
#define LOW CblasLower
#define NUN CblasNonUnit
#define UNT CblasUnit
#define LFT CblasLeft
#define RGT CblasRight

double get_double_by_name(SEXP obj, char *nm);
SEXP set_double_by_name(SEXP obj, double val, char *nm);
SEXP as_det_obj(double val, int log, int sign);
SEXP get_factors(SEXP obj, char *nm);
SEXP set_factors(SEXP obj, SEXP val, char *nm);

#if 0
SEXP dgCMatrix_set_Dim(SEXP x, int nrow);
#endif  /* unused */

/* int csc_unsorted_columns(int ncol, const int p[], const int i[]); */
/* void csc_sort_columns(int ncol, const int p[], int i[], double x[]); */
/* SEXP csc_check_column_sorting(SEXP A); */

SEXP check_scalar_string(SEXP sP, char *vals, char *nm);
Rboolean equal_string_vectors(SEXP s1, SEXP s2);

void d_packed_getDiag(double *dest, SEXP x, int n);
void l_packed_getDiag(   int *dest, SEXP x, int n);
void tr_d_packed_getDiag(double *dest, SEXP x);
void tr_l_packed_getDiag(   int *dest, SEXP x);

SEXP Matrix_getElement(SEXP list, char *nm);

#define PACKED_TO_FULL(TYPE)                                            \
TYPE *packed_to_full_ ## TYPE(TYPE *dest, const TYPE *src,              \
                             int n, enum CBLAS_UPLO uplo)
PACKED_TO_FULL(double);
PACKED_TO_FULL(int);
#undef PACKED_TO_FULL

#define FULL_TO_PACKED(TYPE)                                            \
TYPE *full_to_packed_ ## TYPE(TYPE *dest, const TYPE *src, int n,       \
                              enum CBLAS_UPLO uplo, enum CBLAS_DIAG diag)
FULL_TO_PACKED(double);
FULL_TO_PACKED(int);
#undef FULL_TO_PACKED


extern   /* stored pointers to symbols initialized in R_init_Matrix */
#include "Syms.h"

/* zero an array */
#define AZERO(x, n) {int _I_, _SZ_ = (n); for(_I_ = 0; _I_ < _SZ_; _I_++) (x)[_I_] = 0;}

/* number of elements in one triangle of a square matrix of order n */
#define PACKED_LENGTH(n)   ((n) * ((n) + 1))/2

/* duplicate the slot with name given by sym from src to dest */

#define slot_dup(dest, src, sym)  SET_SLOT(dest, sym, duplicate(GET_SLOT(src, sym)))

/* is not yet used: */
#define slot_nonNull_dup(dest, src, sym)                        \
    if(GET_SLOT(src, sym) != R_NilValue)                        \
        SET_SLOT(dest, sym, duplicate(GET_SLOT(src, sym)))

#define slot_dup_if_has(dest, src, sym)                         \
    if(R_has_slot(src, sym))                                    \
        SET_SLOT(dest, sym, duplicate(GET_SLOT(src, sym)))

/* TODO: Make this faster for the case where dimnames = list(NULL,NULL)
 *       and hence don't have to be set ! */
#define SET_DimNames(dest, src) slot_dup(dest, src, Matrix_DimNamesSym)


#define uplo_P(_x_) CHAR(STRING_ELT(GET_SLOT(_x_, Matrix_uploSym), 0))
#define diag_P(_x_) CHAR(STRING_ELT(GET_SLOT(_x_, Matrix_diagSym), 0))
#define class_P(_x_) CHAR(asChar(getAttrib(_x_, R_ClassSymbol)))

// Define this "Cholmod compatible" to some degree
enum x_slot_kind {x_pattern=-1, x_double=0, x_logical=1, x_integer=2, x_complex=3};
//                  n             d           l            i            z

/* should also work for "matrix" matrices: */
#define Real_KIND(_x_)  (IS_S4_OBJECT(_x_) ? Real_kind(_x_) : \
                         (isReal(_x_) ? x_double : (isLogical(_x_) ? x_logical : -1)))
/* This one gives '0' also for integer "matrix" :*/
#define Real_KIND2(_x_) (IS_S4_OBJECT(_x_) ? Real_kind(_x_) : \
                         (isLogical(_x_) ? x_logical : 0))

/* requires 'x' slot: */
#define Real_kind(_x_)  (isReal(GET_SLOT(_x_, Matrix_xSym)) ? 0 :       \
                         (isLogical(GET_SLOT(_x_, Matrix_xSym)) ? 1 : -1))

#define DECLARE_AND_GET_X_SLOT(__C_TYPE, __SEXP)        \
    __C_TYPE *xx = __SEXP(GET_SLOT(x, Matrix_xSym))


static R_INLINE
int packed_ncol(int len)
{
    int disc = 8 * len + 1;     /* discriminant */
    int sqrtd = (int) sqrt((double) disc);

    if (len < 0 || disc != sqrtd * sqrtd)
        error(_("invalid 'len' = %d in packed_ncol"));
    return (sqrtd - 1)/2;
}

static R_INLINE
SEXP ALLOC_SLOT(SEXP obj, SEXP nm, SEXPTYPE type, int length)
{
    SEXP val = allocVector(type, length);

    SET_SLOT(obj, nm, val);
    return val;
}

static R_INLINE
int* expand_cmprPt(int ncol, const int mp[], int mj[])
{
    int j;
    for (j = 0; j < ncol; j++) {
        int j2 = mp[j+1], jj;
        for (jj = mp[j]; jj < j2; jj++) mj[jj] = j;
    }
    return mj;
}

static R_INLINE
Rboolean any_NA_in_x(SEXP obj)
{
    double *x = REAL(GET_SLOT(obj, Matrix_xSym));
    int i, n = LENGTH(GET_SLOT(obj, Matrix_xSym));
    for(i=0; i < n; i++)
        if(ISNAN(x[i])) return TRUE;
    /* else */
    return FALSE;
}


void make_d_matrix_triangular(double *x, SEXP from);
void make_i_matrix_triangular(   int *x, SEXP from);

void make_d_matrix_symmetric(double *to, SEXP from);
void make_i_matrix_symmetric(   int *to, SEXP from);

SEXP Matrix_expand_pointers(SEXP pP);

SEXP dup_mMatrix_as_dgeMatrix(SEXP A);
SEXP dup_mMatrix_as_geMatrix (SEXP A);

SEXP new_dgeMatrix(int nrow, int ncol);
SEXP m_encodeInd (SEXP ij, SEXP di, SEXP chk_bnds);
SEXP m_encodeInd2(SEXP i, SEXP j, SEXP di, SEXP chk_bnds);


static R_INLINE SEXP
mMatrix_as_dgeMatrix(SEXP A)
{
    return strcmp(class_P(A), "dgeMatrix") ? dup_mMatrix_as_dgeMatrix(A) : A;
}

static R_INLINE SEXP
mMatrix_as_geMatrix(SEXP A)
{
    return strcmp(class_P(A) + 1, "geMatrix") ? dup_mMatrix_as_geMatrix(A) : A;
}

// Keep centralized --- *and* in sync with ../inst/include/Matrix.h :
#define MATRIX_VALID_dense                      \
        "dmatrix", "dgeMatrix",                 \
        "lmatrix", "lgeMatrix",                 \
        "nmatrix", "ngeMatrix",                 \
        "zmatrix", "zgeMatrix"

#define MATRIX_VALID_Csparse                    \
 "dgCMatrix", "dsCMatrix", "dtCMatrix",         \
 "lgCMatrix", "lsCMatrix", "ltCMatrix",         \
 "ngCMatrix", "nsCMatrix", "ntCMatrix",         \
 "zgCMatrix", "zsCMatrix", "ztCMatrix"

#define MATRIX_VALID_Tsparse                    \
 "dgTMatrix", "dsTMatrix", "dtTMatrix",         \
 "lgTMatrix", "lsTMatrix", "ltTMatrix",         \
 "ngTMatrix", "nsTMatrix", "ntTMatrix",         \
 "zgTMatrix", "zsTMatrix", "ztTMatrix"

#define MATRIX_VALID_Rsparse                    \
 "dgRMatrix", "dsRMatrix", "dtRMatrix",         \
 "lgRMatrix", "lsRMatrix", "ltRMatrix",         \
 "ngRMatrix", "nsRMatrix", "ntRMatrix",         \
 "zgRMatrix", "zsRMatrix", "ztRMatrix"

#define MATRIX_VALID_CHMfactor "dCHMsuper", "dCHMsimpl", "nCHMsuper", "nCHMsimpl"

static R_INLINE int
Matrix_check_class(char *class, const char **valid)
{
    int ans;
    for (ans = 0; ; ans++) {
        if (!strlen(valid[ans])) return -1;
        if (!strcmp(class, valid[ans])) return ans;
    }
}

int Matrix_check_class_etc(SEXP x, const char **valid);
#if R_VERSION < R_Version(2, 13, 0)
int Matrix_check_class_and_super(SEXP x, const char **valid, SEXP rho);
#else
# define Matrix_check_class_and_super R_check_class_and_super
#endif


// Type_ans sparseVector_sub(int64_t i, int nnz_v, int* v_i, Type_ans* v_x, int len_v):

/* Define all of
 *  dsparseVector_sub(....)
 *  isparseVector_sub(....)
 *  lsparseVector_sub(....)
 *  nsparseVector_sub(....)
 *  zsparseVector_sub(....)
 */
#define _dspV_
#include "t_sparseVector.c"

#define _ispV_
#include "t_sparseVector.c"

#define _lspV_
#include "t_sparseVector.c"

#define _nspV_
#include "t_sparseVector.c"

#define _zspV_
#include "t_sparseVector.c"


#ifdef __cplusplus
}
#endif

#endif /* MATRIX_MUTILS_H_ */