#include <math.h>
#include "Mdefines.h"
#include "validity.h"

Macros
#define	MK(_FORMAT_) mkString(_FORMAT_ )

#define	MS(_FORMAT_, ...) Matrix_sprintf(_FORMAT_, __VA_ARGS__)

#define	RMK(_FORMAT_) return MK( _FORMAT_ )

#define	RMS(_FORMAT_, ...) return MS(_FORMAT_, __VA_ARGS__)

#define	RMKMS(_FORMAT_, ...) return MK(MS(_FORMAT_, __VA_ARGS__))

#define	FRMKMS(_FORMAT_, ...)

#define	KINDMATRIX_VALIDATE(_PREFIX_, _SEXPTYPE_)

#define	KINDVECTOR_VALIDATE(_PREFIX_, _SEXPTYPE_)

#define	IS_VALID(_CLASS_)

#define	IS_VALID_SPARSE(_C_)

Functions
char *	Dim_validate (SEXP dim)

SEXP	R_Dim_validate (SEXP dim)

char *	DimNames_validate (SEXP dimnames, int *pdim)

SEXP	R_DimNames_validate (SEXP dimnames, SEXP dim)

SEXP	R_DimNames_fixup (SEXP dimnames)

SEXP	Matrix_validate (SEXP obj)

SEXP	MatrixFactorization_validate (SEXP obj)

SEXP	generalMatrix_validate (SEXP obj)

SEXP	symmetricMatrix_validate (SEXP obj)

SEXP	triangularMatrix_validate (SEXP obj)

SEXP	unpackedMatrix_validate (SEXP obj)

SEXP	packedMatrix_validate (SEXP obj)

SEXP	CsparseMatrix_validate (SEXP obj)

SEXP	RsparseMatrix_validate (SEXP obj)

SEXP	TsparseMatrix_validate (SEXP obj)

SEXP	diagonalMatrix_validate (SEXP obj)

SEXP	indMatrix_validate (SEXP obj)

SEXP	pMatrix_validate (SEXP obj)

SEXP	sCMatrix_validate (SEXP obj)

SEXP	tCMatrix_validate (SEXP obj)

SEXP	sRMatrix_validate (SEXP obj)

SEXP	tRMatrix_validate (SEXP obj)

SEXP	sTMatrix_validate (SEXP obj)

SEXP	tTMatrix_validate (SEXP obj)

SEXP	xgCMatrix_validate (SEXP obj)

SEXP	xsCMatrix_validate (SEXP obj)

SEXP	xtCMatrix_validate (SEXP obj)

SEXP	xgRMatrix_validate (SEXP obj)

SEXP	xsRMatrix_validate (SEXP obj)

SEXP	xtRMatrix_validate (SEXP obj)

SEXP	xgTMatrix_validate (SEXP obj)

SEXP	xsTMatrix_validate (SEXP obj)

SEXP	xtTMatrix_validate (SEXP obj)

SEXP	dpoMatrix_validate (SEXP obj)

SEXP	dppMatrix_validate (SEXP obj)

SEXP	corMatrix_validate (SEXP obj)

SEXP	copMatrix_validate (SEXP obj)

SEXP	sparseVector_validate (SEXP obj)

SEXP	denseLU_validate (SEXP obj)

SEXP	sparseLU_validate (SEXP obj)

SEXP	sparseQR_validate (SEXP obj)

SEXP	BunchKaufman_validate (SEXP obj)

SEXP	pBunchKaufman_validate (SEXP obj)

SEXP	Cholesky_validate (SEXP obj)

SEXP	pCholesky_validate (SEXP obj)

SEXP	CHMfactor_validate (SEXP obj)

SEXP	CHMsimpl_validate (SEXP obj)

SEXP	CHMsuper_validate (SEXP obj)

SEXP	dCHMsimpl_validate (SEXP obj)

SEXP	dCHMsuper_validate (SEXP obj)

SEXP	Schur_validate (SEXP obj)

void	validObject (SEXP obj, const char *cl)

Macro Definition Documentation

◆ FRMKMS

#define FRMKMS	(	_FORMAT_,
		...
	)

Value:

    do { \
        Matrix_Free(work, lwork); \
        RMKMS(_FORMAT_, __VA_ARGS__); \
    } while (0)

Definition at line 15 of file validity.c.

◆ IS_VALID

#define IS_VALID ( _CLASS_ )

Value:

    do { \
        status = _CLASS_ ## _validate(obj); \
        if (TYPEOF(status) == STRSXP) \
            error(_("invalid class \"%s\" object: %s"), \
                  cl, CHAR(STRING_ELT(status, 0))); \
    } while (0)

◆ IS_VALID_SPARSE

#define IS_VALID_SPARSE ( _C_ )

Value:

    do { \
        IS_VALID(_C_ ## sparseMatrix); \
        if (cl[0] == 'n') { \
            if (cl[1] == 's') \
                IS_VALID(s ## _C_ ## Matrix); \
            else if (cl[1] == 't') \
                IS_VALID(t ## _C_ ## Matrix); \
        } else { \
            if (cl[1] == 'g') \
                IS_VALID(xg ## _C_ ## Matrix); \
            else if (cl[1] == 's') \
                IS_VALID(xs ## _C_ ## Matrix); \
            else if (cl[1] == 't') \
                IS_VALID(xt ## _C_ ## Matrix); \
        } \
    } while (0)

◆ KINDMATRIX_VALIDATE

#define KINDMATRIX_VALIDATE	(	_PREFIX_,
		_SEXPTYPE_
	)

Value:

SEXP _PREFIX_ ## Matrix_validate(SEXP obj) \
{ \
    SEXP x = GET_SLOT(obj, Matrix_xSym); \
    if (TYPEOF(x) != _SEXPTYPE_) \
        RMKMS(_("'%s' slot is not of type \"%s\""), "x", type2char(_SEXPTYPE_)); \
    return ScalarLogical(1); \
}

Definition at line 145 of file validity.c.

◆ KINDVECTOR_VALIDATE

#define KINDVECTOR_VALIDATE	(	_PREFIX_,
		_SEXPTYPE_
	)

Value:

SEXP _PREFIX_ ## sparseVector_validate(SEXP obj) \
{ \
    SEXP x = PROTECT(GET_SLOT(obj, Matrix_xSym)), \
        i = PROTECT(GET_SLOT(obj, Matrix_iSym)); \
    UNPROTECT(2); /* i, x */ \
    if (TYPEOF(x) != _SEXPTYPE_) \
        RMKMS(_("'%s' slot is not of type \"%s\""), "x", type2char(_SEXPTYPE_)); \
    if (XLENGTH(x) != XLENGTH(i)) \
        RMKMS(_("'%s' and '%s' slots do not have equal length"), "i", "x"); \
    return ScalarLogical(1); \
}