nl_matrix.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#include "nl_private.h"
 
#ifndef OPENNL_MATRIX_H
#define OPENNL_MATRIX_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
/******************************************************************************/
/* Abstract matrix interface */
 
    struct NLMatrixStruct;
    typedef struct NLMatrixStruct* NLMatrix;
 
    typedef void(*NLDestroyMatrixFunc)(NLMatrix M);
 
    typedef void(*NLMultMatrixVectorFunc)(NLMatrix M, const double* x, double* y);
 
#define NL_MATRIX_SPARSE_DYNAMIC 0x1001
#define NL_MATRIX_CRS            0x1002
#define NL_MATRIX_SUPERLU_EXT    0x1003
#define NL_MATRIX_CHOLMOD_EXT    0x1004
#define NL_MATRIX_FUNCTION       0x1005
#define NL_MATRIX_OTHER          0x1006
 
    struct NLMatrixStruct {
        NLuint m;
 
        NLuint n;
 
        NLenum type;
 
        NLDestroyMatrixFunc destroy_func;
 
        NLMultMatrixVectorFunc mult_func;
    };
 
    NLAPI void NLAPIENTRY nlDeleteMatrix(NLMatrix M);
 
    NLAPI void NLAPIENTRY nlMultMatrixVector(
        NLMatrix M, const double* x, double* y
    );
 
/******************************************************************************/
/* Dynamic arrays for sparse row/columns */
 
    typedef struct  {
        NLuint index;
 
        NLdouble value;
    } NLCoeff;
 
    typedef struct {
        NLuint size;
 
        NLuint capacity;
 
        NLCoeff* coeff;
    } NLRowColumn;
 
    NLAPI void NLAPIENTRY nlRowColumnConstruct(NLRowColumn* c);
 
    NLAPI void NLAPIENTRY nlRowColumnDestroy(NLRowColumn* c);
 
    NLAPI void NLAPIENTRY nlRowColumnGrow(NLRowColumn* c);
 
    NLAPI void NLAPIENTRY nlRowColumnAdd(
        NLRowColumn* c, NLuint index, NLdouble value
    );
 
    NLAPI void NLAPIENTRY nlRowColumnAppend(
        NLRowColumn* c, NLuint index, NLdouble value
    );
 
    NLAPI void NLAPIENTRY nlRowColumnZero(NLRowColumn* c);
 
    NLAPI void NLAPIENTRY nlRowColumnClear(NLRowColumn* c);
 
    NLAPI void NLAPIENTRY nlRowColumnSort(NLRowColumn* c);
 
/******************************************************************************/
/* Compressed Row Storage */
 
#ifdef GARGANTUA
    typedef NLulong NLuint_big;
#else
    typedef NLuint NLuint_big;
#endif
 
 
    typedef struct {
        NLuint m;
 
        NLuint n;
 
        NLenum type;
 
        NLDestroyMatrixFunc destroy_func;
 
        NLMultMatrixVectorFunc mult_func;
 
        NLdouble* val;
 
        NLuint_big* rowptr;
 
        NLuint* colind;
 
        NLuint nslices;
 
        NLuint* sliceptr;
 
        NLboolean symmetric_storage;
    } NLCRSMatrix;
 
    NLAPI void NLAPIENTRY nlCRSMatrixConstruct(
        NLCRSMatrix* M, NLuint m, NLuint n, NLuint_big nnz, NLuint nslices
    );
 
    NLAPI void NLAPIENTRY nlCRSMatrixConstructSymmetric(
        NLCRSMatrix* M, NLuint n, NLuint_big nnz
    );
 
 
    NLAPI void NLAPIENTRY nlCRSMatrixConstructPattern(
        NLCRSMatrix* M, NLuint m, NLuint n
    );
 
    NLAPI void NLAPIENTRY nlCRSMatrixConstructPatternSymmetric(
        NLCRSMatrix* M, NLuint n
    );
 
    NLAPI void NLAPIENTRY nlCRSMatrixPatternSetRowLength(
        NLCRSMatrix* M, NLuint i, NLuint n
    );
 
 
    NLAPI void NLAPIENTRY nlCRSMatrixPatternCompile(NLCRSMatrix* M);
 
    NLAPI NLulong NLAPIENTRY nlCRSMatrixAdd(
        NLCRSMatrix* M, NLuint i, NLuint j, NLdouble value
    );
 
    NLAPI void NLAPIENTRY nlCRSMatrixAddAt(
        NLCRSMatrix* M, NLuint i, NLuint j, NLdouble value, NLulong index
    );
 
    NLAPI void NLAPIENTRY nlCRSMatrixSetCoefficientAtRowOffset(
        NLCRSMatrix* M, NLuint i, NLuint j, NLdouble value, NLuint row_offset
    );
 
    NLAPI NLboolean NLAPIENTRY nlCRSMatrixLoad(
        NLCRSMatrix* M, const char* filename
    );
 
    NLAPI NLboolean NLAPIENTRY nlCRSMatrixSave(
        NLCRSMatrix* M, const char* filename
    );
 
    NLAPI NLuint_big NLAPIENTRY nlCRSMatrixNNZ(NLCRSMatrix* M);
 
/******************************************************************************/
/* SparseMatrix data structure */
 
#define NL_MATRIX_STORE_ROWS          1
 
#define NL_MATRIX_STORE_COLUMNS       2
 
#define NL_MATRIX_STORE_SYMMETRIC     4
 
    typedef struct {
        NLuint m;
 
        NLuint n;
 
        NLenum type;
 
        NLDestroyMatrixFunc destroy_func;
 
        NLMultMatrixVectorFunc mult_func;
 
 
        NLuint diag_size;
 
        NLuint diag_capacity;
 
        NLenum storage;
 
        NLRowColumn* row;
 
        NLRowColumn* column;
 
        NLdouble*    diag;
 
        NLuint row_capacity;
 
        NLuint column_capacity;
 
    } NLSparseMatrix;
 
 
    NLAPI NLMatrix NLAPIENTRY nlSparseMatrixNew(
        NLuint m, NLuint n, NLenum storage
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixConstruct(
        NLSparseMatrix* M, NLuint m, NLuint n, NLenum storage
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixDestroy(NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixMult(
        NLSparseMatrix* A, const NLdouble* x, NLdouble* y
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixAdd(
        NLSparseMatrix* M, NLuint i, NLuint j, NLdouble value
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixAddMatrix(
        NLSparseMatrix* M, double mul, const NLMatrix N
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixZero( NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixClear( NLSparseMatrix* M);
 
    NLAPI NLuint_big NLAPIENTRY nlSparseMatrixNNZ( NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixSort( NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixAddRow( NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixAddColumn( NLSparseMatrix* M);
 
    NLAPI void NLAPIENTRY nlSparseMatrixMAddRow(
        NLSparseMatrix* M, NLuint i1, double s, NLuint i2
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixScaleRow(
        NLSparseMatrix* M, NLuint i, double s
    );
 
    NLAPI void NLAPIENTRY nlSparseMatrixZeroRow(
        NLSparseMatrix* M, NLuint i
    );
 
 
/******************************************************************************/
 
    NLAPI NLMatrix NLAPIENTRY nlCRSMatrixNewFromSparseMatrix(NLSparseMatrix* M);
 
    NLAPI NLMatrix NLAPIENTRY nlCRSMatrixNewFromSparseMatrixSymmetric(
        NLSparseMatrix* M
    );
 
 
    NLAPI void NLAPIENTRY nlMatrixCompress(NLMatrix* M);
 
    NLAPI NLuint_big NLAPIENTRY nlMatrixNNZ(NLMatrix M);
 
    NLAPI NLMatrix NLAPIENTRY nlMatrixFactorize(NLMatrix M, NLenum solver);
 
/******************************************************************************/
 
    typedef void(*NLMatrixFunc)(const double* x, double* y);
 
    NLAPI NLMatrix NLAPIENTRY nlMatrixNewFromFunction(
        NLuint m, NLuint n, NLMatrixFunc func
    );
 
    NLAPI NLMatrixFunc NLAPIENTRY nlMatrixGetFunction(NLMatrix M);
 
/******************************************************************************/
 
    NLAPI NLMatrix NLAPIENTRY nlMatrixNewFromProduct(
        NLMatrix M, NLboolean product_owns_M,
        NLMatrix N, NLboolean product_owns_N
    );
 
/******************************************************************************/
 
#ifdef __cplusplus
}
#endif
 
#endif