nl_context.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
 *
 */
 
#ifndef OPENNL_CONTEXT_H
#define OPENNL_CONTEXT_H
 
#include "nl_private.h"
#include "nl_matrix.h"
 
/******************************************************************************/
/* NLContext data structure */
 
 
typedef NLboolean(*NLSolverFunc)(void);
 
typedef void(*NLProgressFunc)(
    NLuint cur_iter, NLuint max_iter, double cur_err, double max_err
);
 
#define NL_STATE_INITIAL                0
#define NL_STATE_SYSTEM                 1
#define NL_STATE_MATRIX                 2
#define NL_STATE_ROW                    3
#define NL_STATE_MATRIX_CONSTRUCTED     4
#define NL_STATE_SYSTEM_CONSTRUCTED     5
#define NL_STATE_SOLVED                 6
#define NL_STATE_MATRIX_PATTERN         7
 
typedef struct {
    void* base_address;
    NLuint stride;
} NLBufferBinding;
 
#define NL_BUFFER_ITEM(B,i)                                             \
    *(double*)((void*)((char*)((B).base_address)+((i)*(B).stride)))
 
 
typedef struct {
    NLenum           state;
 
    NLboolean        user_variable_buffers;
 
    NLBufferBinding* variable_buffer;
 
    NLdouble*        variable_value;
 
    NLboolean*       variable_is_locked;
 
    NLuint*          variable_index;
 
    NLuint           n;
 
 
    NLenum           matrix_mode;
 
    NLMatrix         M;
 
    NLMatrix         P;
 
    NLMatrix         B;
 
    NLRowColumn      af;
 
    NLRowColumn      al;
 
    NLdouble*        x;
 
    NLdouble*        b;
 
    NLdouble*        right_hand_side;
 
    NLdouble         row_scaling;
 
    NLenum           solver;
 
    NLenum           preconditioner;
 
    NLboolean        preconditioner_defined;
 
    NLuint           nb_variables;
 
    NLuint           nb_systems;
 
    NLboolean        ij_coefficient_called;
 
    NLuint           current_row;
 
    NLboolean        least_squares;
 
    NLboolean        symmetric;
 
    NLuint           max_iterations;
 
 
    NLboolean        max_iterations_defined;
 
    NLuint           inner_iterations;
 
    NLdouble         threshold;
 
    NLboolean        threshold_defined;
 
    NLdouble         omega;
 
    NLboolean        normalize_rows;
 
    NLuint           used_iterations;
 
    NLdouble         error;
 
 
    NLdouble         start_time;
 
    NLdouble         elapsed_time;
 
    NLSolverFunc     solver_func;
 
    NLProgressFunc   progress_func;
 
    NLboolean        verbose;
 
    NLulong          flops;
 
    NLenum           eigen_solver;
 
    NLdouble         eigen_shift;
 
    NLboolean        eigen_shift_invert;
 
    NLdouble*        eigen_value;
 
    NLdouble*        temp_eigen_value;
 
    NLboolean        has_matrix_pattern;
 
    NLboolean        no_variables_indirection;
 
} NLContextStruct;
 
extern NLContextStruct* nlCurrentContext;
 
void nlCheckState(NLenum state);
 
void nlTransition(NLenum from_state, NLenum to_state);
 
NLboolean nlDefaultSolver(void);
 
#endif