solver.h

Go to the documentation of this file.

/*
 *   Copyright 2023 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_ALP_SPARSE_LINSOLVERS
#define _H_ALP_SPARSE_LINSOLVERS

#include <stddef.h> // for size_t


#ifdef __cplusplus
extern "C" {
#endif

typedef enum {

    NO_ERROR,

    NULL_ARGUMENT,

    ILLEGAL_ARGUMENT,

    OUT_OF_MEMORY,

    FAILED,

    UNKNOWN

} sparse_err_t;

typedef void * sparse_cg_handle_t;

typedef int (*sparse_cg_preconditioner_sxx_t) (
    float * const,
    const float * const,
    void * const
);

typedef int (*sparse_cg_preconditioner_dxx_t) (
    double * const,
    const double * const,
    void * const
);

sparse_err_t sparse_cg_init_sii(
    sparse_cg_handle_t * const handle, const size_t n,
    const float * const a, const int * const ja, const int * const ia
);

sparse_err_t sparse_cg_init_dii(
    sparse_cg_handle_t * const handle, const size_t n,
    const double * const a, const int * const ja, const int * const ia
);

sparse_err_t sparse_cg_init_siz(
    sparse_cg_handle_t * const handle, const size_t n,
    const float * const a, const int * const ja, const size_t * const ia
);

sparse_err_t sparse_cg_init_diz(
    sparse_cg_handle_t * const handle, const size_t n,
    const double * const a, const int * const ja, const size_t * const ia
);

sparse_err_t sparse_cg_init_szz(
    sparse_cg_handle_t * const handle, const size_t n,
    const float * const a, const size_t * const ja, const size_t * const ia
);

sparse_err_t sparse_cg_init_dzz(
    sparse_cg_handle_t * const handle, const size_t n,
    const double * const a, const size_t * const ja, const size_t * const ia
);

// Note that szi and dzi are skipped on purpose. Such variants would not seem
// sensible, though could easily be provided if they do turn out to be needed

sparse_err_t sparse_cg_get_size_sii(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_size_siz(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_size_szz(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_size_dii(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_size_diz(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_size_dzz(
    sparse_cg_handle_t const handle, size_t * const size
);

sparse_err_t sparse_cg_get_tolerance_sii(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_tolerance_siz(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_tolerance_szz(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_tolerance_dii(
    const sparse_cg_handle_t handle, double * const tol );

sparse_err_t sparse_cg_get_tolerance_diz(
    const sparse_cg_handle_t handle, double * const tol );

sparse_err_t sparse_cg_get_tolerance_dzz(
    const sparse_cg_handle_t handle, double * const tol );


sparse_err_t sparse_cg_set_tolerance_sii(
    sparse_cg_handle_t handle, const float tol );

sparse_err_t sparse_cg_set_tolerance_siz(
    sparse_cg_handle_t handle, const float tol );

sparse_err_t sparse_cg_set_tolerance_szz(
    sparse_cg_handle_t handle, const float tol );

sparse_err_t sparse_cg_set_tolerance_dii(
    sparse_cg_handle_t handle, const double tol );

sparse_err_t sparse_cg_set_tolerance_diz(
    sparse_cg_handle_t handle, const double tol );

sparse_err_t sparse_cg_set_tolerance_dzz(
    sparse_cg_handle_t handle, const double tol );

sparse_err_t sparse_cg_set_max_iter_count_sii(
    sparse_cg_handle_t handle, const size_t max_iters );

sparse_err_t sparse_cg_set_max_iter_count_siz(
    sparse_cg_handle_t handle, const size_t max_iters );

sparse_err_t sparse_cg_set_max_iter_count_szz(
    sparse_cg_handle_t handle, const size_t max_iters );

sparse_err_t sparse_cg_set_max_iter_count_dii(
    sparse_cg_handle_t handle, const size_t max_iters );

sparse_err_t sparse_cg_set_max_iter_count_diz(
    sparse_cg_handle_t handle, const size_t max_iters );

sparse_err_t sparse_cg_set_max_iter_count_dzz(
    sparse_cg_handle_t handle, const size_t max_iters );

// other variants of sparse_cg_set_max_iter_count could take int, uint, etc.
// inputs


sparse_err_t sparse_cg_get_residual_sii(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_residual_siz(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_residual_szz(
    const sparse_cg_handle_t handle, float * const tol );

sparse_err_t sparse_cg_get_residual_dii(
    const sparse_cg_handle_t handle, double * const tol );

sparse_err_t sparse_cg_get_residual_diz(
    const sparse_cg_handle_t handle, double * const tol );

sparse_err_t sparse_cg_get_residual_dzz(
    const sparse_cg_handle_t handle, double * const tol );


sparse_err_t sparse_cg_get_iter_count_sii(
    const sparse_cg_handle_t handle, size_t * const iters );

sparse_err_t sparse_cg_get_iter_count_siz(
    const sparse_cg_handle_t handle, size_t * const iters );

sparse_err_t sparse_cg_get_iter_count_szz(
    const sparse_cg_handle_t handle, size_t * const iters );

sparse_err_t sparse_cg_get_iter_count_dii(
    const sparse_cg_handle_t handle, size_t * const iters );

sparse_err_t sparse_cg_get_iter_count_diz(
    const sparse_cg_handle_t handle, size_t * const iters );

sparse_err_t sparse_cg_get_iter_count_dzz(
    const sparse_cg_handle_t handle, size_t * const iters );

// another variant of sparse_cg_get_iter_count could provide output as an int,
// uint, etc.

sparse_err_t sparse_cg_get_preconditioner_sii(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_sxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_get_preconditioner_siz(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_sxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_get_preconditioner_szz(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_sxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_get_preconditioner_dii(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_dxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_get_preconditioner_diz(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_dxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_get_preconditioner_dzz(
    const sparse_cg_handle_t handle,
    sparse_cg_preconditioner_dxx_t * const preconditioner,
    void * * const data
);

sparse_err_t sparse_cg_set_preconditioner_sii(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_sxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_set_preconditioner_dii(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_dxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_set_preconditioner_siz(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_sxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_set_preconditioner_diz(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_dxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_set_preconditioner_szz(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_sxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_set_preconditioner_dzz(
    const sparse_cg_handle_t handle,
    const sparse_cg_preconditioner_dxx_t preconditioner,
    void * const data
);

sparse_err_t sparse_cg_solve_sii(
    sparse_cg_handle_t handle, float * const x, const float * const b );

sparse_err_t sparse_cg_solve_siz(
    sparse_cg_handle_t handle, float * const x, const float * const b );

sparse_err_t sparse_cg_solve_szz(
    sparse_cg_handle_t handle, float * const x, const float * const b );

sparse_err_t sparse_cg_solve_dii(
    sparse_cg_handle_t handle, double * const x, const double * const b );

sparse_err_t sparse_cg_solve_diz(
    sparse_cg_handle_t handle, double * const x, const double * const b );

sparse_err_t sparse_cg_solve_dzz(
    sparse_cg_handle_t handle, double * const x, const double * const b );


sparse_err_t sparse_cg_destroy_sii( sparse_cg_handle_t handle );

sparse_err_t sparse_cg_destroy_siz( sparse_cg_handle_t handle );

sparse_err_t sparse_cg_destroy_szz( sparse_cg_handle_t handle );

sparse_err_t sparse_cg_destroy_dii( sparse_cg_handle_t handle );

sparse_err_t sparse_cg_destroy_diz( sparse_cg_handle_t handle );

sparse_err_t sparse_cg_destroy_dzz( sparse_cg_handle_t handle );
 // ends doxygen page for the solver library

#ifdef __cplusplus
} // end extern "C"
#endif

#endif // end ifdef _H_ALP_LINSOLVERS