cwrapper.h

#ifndef CWRAPPER_H
#define CWRAPPER_H
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "symengine/symengine_config.h"
 
#ifdef HAVE_SYMENGINE_GMP
#include <gmp.h>
#endif
 
#ifdef HAVE_SYMENGINE_MPFR
#include <mpfr.h>
#endif // HAVE_SYMENGINE_MPFR
 
#include "symengine/symengine_exception.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Use SYMENGINE_C_ASSERT in C tests
#define SYMENGINE_C_ASSERT(cond)                                               \
    {                                                                          \
        if (0 == (cond)) {                                                     \
            printf("SYMENGINE_C_ASSERT failed: %s \nfunction %s (), line "     \
                   "number %d at\n%s\n",                                       \
                   __FILE__, __func__, __LINE__, #cond);                       \
            abort();                                                           \
        }                                                                      \
    }
 
typedef symengine_exceptions_t CWRAPPER_OUTPUT_TYPE;
 
typedef enum {
    SYMENGINE_DOUBLE = 0,
    SYMENGINE_FLOAT = 1,
    SYMENGINE_HALF = 2,
} BasicCodePrinterPrecision;
typedef struct BasicCodePrinterSettings BasicCodePrinterSettings;
 
typedef enum {
#define SYMENGINE_INCLUDE_ALL
#define SYMENGINE_ENUM(type, Class) type,
#include "symengine/type_codes.inc"
#undef SYMENGINE_ENUM
#undef SYMENGINE_INCLUDE_ALL
    SYMENGINE_TypeID_Count
} TypeID;
 
typedef struct dcomplex {
    double real;
    double imag;
} dcomplex;
 
// The size of 'CRCPBasic_C' must be the same as CRCPBasic (which contains a
// single RCP<const Basic> member) *and* they must have the same alignment
// (because we allocate CRCPBasic into the memory occupied by this struct in
// cwrapper.cpp). We cannot use C++ in this file, so we need to use C tools to
// arrive at the correct size and alignment.  The size of the RCP object on
// most platforms (with WITH_SYMENGINE_RCP on) should be just the size of the
// 'T *ptr_' pointer that it contains (as there is no virtual function table)
// and the alignment should also be of a pointer.  So we just put 'void *data'
// as the only member of the struct, that should have the correct size and
// alignment. With WITH_SYMENGINE_RCP off (i.e. using Teuchos::RCP), we have to
// add additional members into the structure.
//
// However, this is checked at compile time in cwrapper.cpp, so if the size or
// alignment is different on some platform, the compilation will fail --- in
// that case one needs to modify the contents of this struct to adjust its size
// and/or alignment.
struct CRCPBasic_C {
    void *data;
#if !defined(WITH_SYMENGINE_RCP)
    void *teuchos_handle;
    int teuchos_strength;
#endif
};
 
//  CRCPBasic, which has the same size and alignment as RCP<const Basic> (see
//  the above comment for details). That is then used by the user to allocate
//  the memory needed for RCP<const Basic> on the stack. A 'basic' type should
//  be initialized using basic_new_stack(), before any function is called.
//  Assignment should be done only by using basic_assign(). Before the variable
//  goes out of scope, basic_free_stack() must be called.
//
//  For downstream projects, define a dummy struct with the right size, so
//  that it can be allocated on the stack.
typedef struct CRCPBasic_C basic_struct;
 
typedef struct CSetBasic CSetBasic;
 
typedef basic_struct basic[1];
 
// 'basic' type, this function initializes an RCP<const Basic> on the stack
// allocated variable. The 's' variable must be freed using basic_free_stack()
SYMENGINE_EXPORT void basic_new_stack(basic s);
SYMENGINE_EXPORT void basic_free_stack(basic s);
 
// Use these two functions to allocate and free 'basic' on a heap. The pointer
// can then be used in all the other methods below (i.e. the methods that
// accept 'basic s' work no matter if 's' is stack or heap allocated).
SYMENGINE_EXPORT basic_struct *basic_new_heap(void);
SYMENGINE_EXPORT void basic_free_heap(basic_struct *s);
 
SYMENGINE_EXPORT const char *symengine_version(void);
 
 
SYMENGINE_EXPORT void basic_const_set(basic s, const char *c);
 
SYMENGINE_EXPORT void basic_const_zero(basic s);
SYMENGINE_EXPORT void basic_const_one(basic s);
SYMENGINE_EXPORT void basic_const_minus_one(basic s);
SYMENGINE_EXPORT void basic_const_I(basic s);
 
SYMENGINE_EXPORT void basic_const_pi(basic s);
SYMENGINE_EXPORT void basic_const_E(basic s);
SYMENGINE_EXPORT void basic_const_EulerGamma(basic s);
SYMENGINE_EXPORT void basic_const_Catalan(basic s);
SYMENGINE_EXPORT void basic_const_GoldenRatio(basic s);
 
SYMENGINE_EXPORT void basic_const_infinity(basic s);
SYMENGINE_EXPORT void basic_const_neginfinity(basic s);
SYMENGINE_EXPORT void basic_const_complex_infinity(basic s);
 
SYMENGINE_EXPORT void basic_const_nan(basic s);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_assign(basic a, const basic b);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_parse(basic b, const char *str);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_parse2(basic b, const char *str,
                                                   int convert_xor);
 
SYMENGINE_EXPORT TypeID basic_get_type(const basic s);
SYMENGINE_EXPORT TypeID basic_get_class_id(const char *c);
SYMENGINE_EXPORT char *basic_get_class_from_id(TypeID id);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE symbol_set(basic s, const char *c);
 
SYMENGINE_EXPORT int number_is_zero(const basic s);
SYMENGINE_EXPORT int number_is_negative(const basic s);
SYMENGINE_EXPORT int number_is_positive(const basic s);
SYMENGINE_EXPORT int number_is_complex(const basic s);
 
SYMENGINE_EXPORT int basic_has_symbol(const basic e, const basic s);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_si(basic s, long i);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_ui(basic s, unsigned long i);
#ifdef HAVE_SYMENGINE_GMP
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_mpz(basic s, const mpz_t i);
#endif
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_str(basic s, const char *c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_double_set_d(basic s, double d);
SYMENGINE_EXPORT double real_double_get_d(const basic s);
 
#ifdef HAVE_SYMENGINE_MPFR
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set_d(basic s, double d,
                                                      int prec);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set_str(basic s, const char *c,
                                                        int prec);
SYMENGINE_EXPORT double real_mpfr_get_d(const basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set(basic s, mpfr_srcptr m);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_get(mpfr_ptr m, const basic s);
SYMENGINE_EXPORT mpfr_prec_t real_mpfr_get_prec(const basic s);
#endif // HAVE_SYMENGINE_MPFR
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_base_real_part(basic s,
                                                             const basic com);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
complex_base_imaginary_part(basic s, const basic com);
 
SYMENGINE_EXPORT signed long integer_get_si(const basic s);
SYMENGINE_EXPORT unsigned long integer_get_ui(const basic s);
#ifdef HAVE_SYMENGINE_GMP
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_get_mpz(mpz_t a, const basic s);
#endif
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set(basic s, const basic i,
                                                   const basic j);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_si(basic s, long i, long j);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_ui(basic s, unsigned long i,
                                                      unsigned long j);
#ifdef HAVE_SYMENGINE_GMP
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_get_mpq(mpq_t a, const basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_mpq(basic s, const mpq_t i);
#endif
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set(basic s, const basic re,
                                                  const basic im);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set_rat(basic s, const basic re,
                                                      const basic im);
#ifdef HAVE_SYMENGINE_GMP
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set_mpq(basic s, const mpq_t re,
                                                      const mpq_t im);
#endif
 
SYMENGINE_EXPORT dcomplex complex_double_get(const basic s);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add(basic s, const basic a,
                                                const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sub(basic s, const basic a,
                                                const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul(basic s, const basic a,
                                                const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_div(basic s, const basic a,
                                                const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_pow(basic s, const basic a,
                                                const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_diff(basic s, const basic expr,
                                                 const basic sym);
SYMENGINE_EXPORT int basic_eq(const basic a, const basic b);
SYMENGINE_EXPORT int basic_neq(const basic a, const basic b);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_expand(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_neg(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_abs(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_erf(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_erfc(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sin(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cos(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_tan(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asin(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acos(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atan(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_csc(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sec(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cot(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acsc(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asec(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acot(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sinh(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cosh(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_tanh(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asinh(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acosh(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atanh(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_csch(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sech(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_coth(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acsch(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asech(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acoth(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_lambertw(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_zeta(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_dirichlet_eta(basic s,
                                                          const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_gamma(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_loggamma(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sqrt(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cbrt(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_exp(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_log(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_floor(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_ceiling(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sign(basic s, const basic a);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atan2(basic s, const basic a,
                                                  const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_kronecker_delta(basic s,
                                                            const basic a,
                                                            const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_lowergamma(basic s, const basic a,
                                                       const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_uppergamma(basic s, const basic a,
                                                       const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_beta(basic s, const basic a,
                                                 const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_polygamma(basic s, const basic a,
                                                      const basic b);
 
SYMENGINE_EXPORT char *basic_dumps(const basic s, unsigned long *size);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_loads(basic s, const char *c,
                                                  unsigned long size);
 
SYMENGINE_EXPORT BasicCodePrinterSettings *basic_code_printer_settings_new();
SYMENGINE_EXPORT void
basic_code_printer_settings_free(BasicCodePrinterSettings *self);
SYMENGINE_EXPORT void
basic_code_printer_settings_set_precision(BasicCodePrinterSettings *self,
                                          BasicCodePrinterPrecision prec);
 
SYMENGINE_EXPORT char *basic_str(const basic s);
SYMENGINE_EXPORT char *basic_str_julia(const basic s);
SYMENGINE_EXPORT char *basic_str_mathml(const basic s);
SYMENGINE_EXPORT char *basic_str_latex(const basic s);
SYMENGINE_EXPORT char *basic_str_ccode(const basic s);
SYMENGINE_EXPORT
char *basic_str_ccode_settings(const basic s,
                               const BasicCodePrinterSettings *settings);
SYMENGINE_EXPORT char *basic_str_cudacode(const basic s);
SYMENGINE_EXPORT
char *basic_str_cudacode_settings(const basic s,
                                  const BasicCodePrinterSettings *settings);
SYMENGINE_EXPORT char *basic_str_metalcode(const basic s);
SYMENGINE_EXPORT char *
basic_str_metalcode_settings(const basic s,
                             const BasicCodePrinterSettings *settings);
SYMENGINE_EXPORT char *basic_str_jscode(const basic s);
SYMENGINE_EXPORT void basic_str_free(char *s);
 
SYMENGINE_EXPORT void bool_set_true(basic s);
SYMENGINE_EXPORT void bool_set_false(basic s);
 
SYMENGINE_EXPORT void basic_set_emptyset(basic s);
SYMENGINE_EXPORT void basic_set_universalset(basic s);
SYMENGINE_EXPORT void basic_set_complexes(basic s);
SYMENGINE_EXPORT void basic_set_reals(basic s);
SYMENGINE_EXPORT void basic_set_rationals(basic s);
SYMENGINE_EXPORT void basic_set_integers(basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_interval(
    basic s, const basic start, const basic end, int left_open, int right_open);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
basic_set_finiteset(basic s, const CSetBasic *container);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_union(basic s, const basic a,
                                                      const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_intersection(basic s,
                                                             const basic a,
                                                             const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_complement(basic s,
                                                           const basic a,
                                                           const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_contains(basic s, const basic a,
                                                         const basic b);
SYMENGINE_EXPORT int basic_set_is_subset(const basic a, const basic b);
SYMENGINE_EXPORT int basic_set_is_proper_subset(const basic a, const basic b);
SYMENGINE_EXPORT int basic_set_is_superset(const basic a, const basic b);
SYMENGINE_EXPORT int basic_set_is_proper_superset(const basic a, const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_inf(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_sup(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_boundary(basic s,
                                                         const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_interior(basic s,
                                                         const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_closure(basic s, const basic a);
 
SYMENGINE_EXPORT int symengine_have_component(const char *c);
 
SYMENGINE_EXPORT int is_a_Number(const basic s);
SYMENGINE_EXPORT int is_a_Integer(const basic s);
SYMENGINE_EXPORT int is_a_Rational(const basic s);
SYMENGINE_EXPORT int is_a_Symbol(const basic s);
SYMENGINE_EXPORT int is_a_Complex(const basic s);
SYMENGINE_EXPORT int is_a_RealDouble(const basic c);
SYMENGINE_EXPORT int is_a_ComplexDouble(const basic c);
SYMENGINE_EXPORT int is_a_RealMPFR(const basic c);
SYMENGINE_EXPORT int is_a_ComplexMPC(const basic c);
SYMENGINE_EXPORT int is_a_Set(const basic c);
 
 
typedef struct CVectorInt CVectorInt;
 
SYMENGINE_EXPORT CVectorInt *vectorint_new(void);
 
// 'data' must point to allocated memory of size 'size'. The function returns 0
// if std::vector<int> can be initialized using placement new into 'data',
// otherwise 1 if 'size' is too small or 2 if 'data' is not properly aligned.
// No memory is leaked either way. Use vectorint_placement_new_check() to check
// that the 'data' and 'size' is properly allocated and aligned. Use
// vectorint_placement_new() to do the actual allocation.
SYMENGINE_EXPORT int vectorint_placement_new_check(void *data, size_t size);
SYMENGINE_EXPORT CVectorInt *vectorint_placement_new(void *data);
 
SYMENGINE_EXPORT void vectorint_placement_free(CVectorInt *self);
 
SYMENGINE_EXPORT void vectorint_free(CVectorInt *self);
SYMENGINE_EXPORT void vectorint_push_back(CVectorInt *self, int value);
SYMENGINE_EXPORT int vectorint_get(CVectorInt *self, int n);
 
 
typedef struct CVecBasic CVecBasic;
 
SYMENGINE_EXPORT CVecBasic *vecbasic_new(void);
SYMENGINE_EXPORT void vecbasic_free(CVecBasic *self);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_push_back(CVecBasic *self,
                                                         const basic value);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_get(CVecBasic *self, size_t n,
                                                   basic result);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_set(CVecBasic *self, size_t n,
                                                   const basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_erase(CVecBasic *self, size_t n);
SYMENGINE_EXPORT size_t vecbasic_size(CVecBasic *self);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_max(basic s, const CVecBasic *d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_min(basic s, const CVecBasic *d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add_vec(basic s,
                                                    const CVecBasic *d);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul_vec(basic s,
                                                    const CVecBasic *d);
 
 
typedef struct CDenseMatrix CDenseMatrix;
typedef struct CSparseMatrix CSparseMatrix;
 
SYMENGINE_EXPORT CDenseMatrix *dense_matrix_new(void);
SYMENGINE_EXPORT CSparseMatrix *sparse_matrix_new(void);
 
SYMENGINE_EXPORT void dense_matrix_free(CDenseMatrix *self);
SYMENGINE_EXPORT CDenseMatrix *
dense_matrix_new_vec(unsigned rows, unsigned cols, CVecBasic *l);
SYMENGINE_EXPORT CDenseMatrix *dense_matrix_new_rows_cols(unsigned r,
                                                          unsigned c);
 
SYMENGINE_EXPORT void sparse_matrix_free(CSparseMatrix *self);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_set(CDenseMatrix *s,
                                                       const CDenseMatrix *d);
 
SYMENGINE_EXPORT char *dense_matrix_str(const CDenseMatrix *s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_rows_cols(CDenseMatrix *mat,
                                                             unsigned r,
                                                             unsigned c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_get_basic(
    basic s, const CDenseMatrix *mat, unsigned long int r, unsigned long int c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_set_basic(
    CDenseMatrix *mat, unsigned long int r, unsigned long int c, basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
sparse_matrix_get_basic(basic s, const CSparseMatrix *mat, unsigned long int r,
                        unsigned long int c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE sparse_matrix_set_basic(
    CSparseMatrix *mat, unsigned long int r, unsigned long int c, basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_det(basic s,
                                                       const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_inv(CDenseMatrix *s,
                                                       const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
dense_matrix_transpose(CDenseMatrix *s, const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_submatrix(
    CDenseMatrix *s, const CDenseMatrix *mat, unsigned long int r1,
    unsigned long int c1, unsigned long int r2, unsigned long int c2,
    unsigned long int r, unsigned long int c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
dense_matrix_row_join(CDenseMatrix *A, const CDenseMatrix *B);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
dense_matrix_col_join(CDenseMatrix *A, const CDenseMatrix *B);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_row_del(CDenseMatrix *C,
                                                           unsigned k);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_col_del(CDenseMatrix *C,
                                                           unsigned k);
 
SYMENGINE_EXPORT unsigned long int dense_matrix_cols(const CDenseMatrix *s);
SYMENGINE_EXPORT unsigned long int dense_matrix_rows(const CDenseMatrix *s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_add_matrix(
    CDenseMatrix *s, const CDenseMatrix *matA, const CDenseMatrix *matB);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_mul_matrix(
    CDenseMatrix *s, const CDenseMatrix *matA, const CDenseMatrix *matB);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_add_scalar(
    CDenseMatrix *s, const CDenseMatrix *matA, const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_mul_scalar(
    CDenseMatrix *s, const CDenseMatrix *matA, const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LU(CDenseMatrix *l,
                                                      CDenseMatrix *u,
                                                      const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LDL(CDenseMatrix *l,
                                                       CDenseMatrix *d,
                                                       const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
dense_matrix_FFLU(CDenseMatrix *lu, const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_FFLDU(
    CDenseMatrix *l, CDenseMatrix *d, CDenseMatrix *u, const CDenseMatrix *mat);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LU_solve(
    CDenseMatrix *x, const CDenseMatrix *A, const CDenseMatrix *b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_ones(CDenseMatrix *s,
                                                        unsigned long int r,
                                                        unsigned long int c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_zeros(CDenseMatrix *s,
                                                         unsigned long int r,
                                                         unsigned long int c);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_diag(CDenseMatrix *s,
                                                        CVecBasic *d,
                                                        long int k);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_eye(CDenseMatrix *s,
                                                       unsigned long int N,
                                                       unsigned long int M,
                                                       int k);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_diff(CDenseMatrix *result,
                                                        const CDenseMatrix *A,
                                                        basic const x);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_jacobian(
    CDenseMatrix *result, const CDenseMatrix *A, const CDenseMatrix *x);
 
SYMENGINE_EXPORT void sparse_matrix_init(CSparseMatrix *s);
SYMENGINE_EXPORT void sparse_matrix_rows_cols(CSparseMatrix *s,
                                              unsigned long int r,
                                              unsigned long int c);
SYMENGINE_EXPORT char *sparse_matrix_str(const CSparseMatrix *s);
 
SYMENGINE_EXPORT int is_a_DenseMatrix(const CDenseMatrix *c);
SYMENGINE_EXPORT int is_a_SparseMatrix(const CSparseMatrix *c);
 
SYMENGINE_EXPORT int dense_matrix_eq(CDenseMatrix *lhs, CDenseMatrix *rhs);
SYMENGINE_EXPORT int sparse_matrix_eq(CSparseMatrix *lhs, CSparseMatrix *rhs);
 
 
SYMENGINE_EXPORT CSetBasic *setbasic_new(void);
SYMENGINE_EXPORT void setbasic_free(CSetBasic *self);
SYMENGINE_EXPORT int setbasic_insert(CSetBasic *self, const basic value);
SYMENGINE_EXPORT void setbasic_get(CSetBasic *self, int n, basic result);
SYMENGINE_EXPORT int setbasic_find(CSetBasic *self, basic value);
SYMENGINE_EXPORT int setbasic_erase(CSetBasic *self, const basic value);
SYMENGINE_EXPORT size_t setbasic_size(CSetBasic *self);
 
 
typedef struct CMapBasicBasic CMapBasicBasic;
 
SYMENGINE_EXPORT CMapBasicBasic *mapbasicbasic_new(void);
SYMENGINE_EXPORT void mapbasicbasic_free(CMapBasicBasic *self);
SYMENGINE_EXPORT void mapbasicbasic_insert(CMapBasicBasic *self,
                                           const basic key, const basic mapped);
SYMENGINE_EXPORT int mapbasicbasic_get(CMapBasicBasic *self, const basic key,
                                       basic mapped);
SYMENGINE_EXPORT size_t mapbasicbasic_size(CMapBasicBasic *self);
 
// -------------------------------------
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_get_args(const basic self,
                                                     CVecBasic *args);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_free_symbols(const basic self,
                                                         CSetBasic *symbols);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_function_symbols(CSetBasic *symbols,
                                                             const basic self);
SYMENGINE_EXPORT size_t basic_hash(const basic self);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_subs(basic s, const basic e,
                                                 const CMapBasicBasic *mapbb);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_subs2(basic s, const basic e,
                                                  const basic a, const basic b);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE function_symbol_set(basic s,
                                                          const char *c,
                                                          const CVecBasic *arg);
SYMENGINE_EXPORT char *function_symbol_get_name(const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_coeff(basic c, const basic b,
                                                  const basic x, const basic n);
 
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_linsolve(CVecBasic *sol,
                                                        const CVecBasic *sys,
                                                        const CVecBasic *sym);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_solve_poly(CSetBasic *r,
                                                       const basic f,
                                                       const basic s);
 
 
SYMENGINE_EXPORT char *ascii_art_str(void);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_gcd(basic s, const basic a,
                                                  const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lcm(basic s, const basic a,
                                                  const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_gcd_ext(basic g, basic s, basic t,
                                                      const basic a,
                                                      const basic b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_nextprime(basic s, const basic a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_mod(basic s, const basic n,
                                                  const basic d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient(basic s, const basic n,
                                                       const basic d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_mod(basic q, basic r,
                                                           const basic n,
                                                           const basic d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_mod_f(basic s, const basic n,
                                                    const basic d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_f(basic s, const basic n,
                                                         const basic d);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_mod_f(basic q, basic r,
                                                             const basic n,
                                                             const basic d);
SYMENGINE_EXPORT int ntheory_mod_inverse(basic b, const basic a, const basic m);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_fibonacci(basic s,
                                                        unsigned long a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_fibonacci2(basic g, basic s,
                                                         unsigned long a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lucas(basic s, unsigned long a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lucas2(basic g, basic s,
                                                     unsigned long a);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_binomial(basic s, const basic a,
                                                       unsigned long b);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_factorial(basic s,
                                                        unsigned long n);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_evalf(basic s, const basic b,
                                                  unsigned long bits, int real);
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_as_numer_denom(basic numer,
                                                           basic denom,
                                                           const basic x);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add_as_two_terms(basic term1,
                                                             basic term2,
                                                             const basic s);
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul_as_two_terms(basic term1,
                                                             basic term2,
                                                             const basic s);
 
typedef struct CLambdaRealDoubleVisitor CLambdaRealDoubleVisitor;
SYMENGINE_EXPORT CLambdaRealDoubleVisitor *lambda_real_double_visitor_new(void);
SYMENGINE_EXPORT void
lambda_real_double_visitor_init(CLambdaRealDoubleVisitor *self,
                                const CVecBasic *args, const CVecBasic *exprs,
                                int perform_cse);
SYMENGINE_EXPORT void
lambda_real_double_visitor_call(CLambdaRealDoubleVisitor *self,
                                double *const outs, const double *const inps);
SYMENGINE_EXPORT void
lambda_real_double_visitor_free(CLambdaRealDoubleVisitor *self);
 
#ifdef HAVE_SYMENGINE_LLVM
// double
typedef struct CLLVMDoubleVisitor CLLVMDoubleVisitor;
SYMENGINE_EXPORT CLLVMDoubleVisitor *llvm_double_visitor_new(void);
SYMENGINE_EXPORT void llvm_double_visitor_init(CLLVMDoubleVisitor *self,
                                               const CVecBasic *args,
                                               const CVecBasic *exprs,
                                               int perform_cse, int opt_level);
SYMENGINE_EXPORT void llvm_double_visitor_call(CLLVMDoubleVisitor *self,
                                               double *const outs,
                                               const double *const inps);
SYMENGINE_EXPORT void llvm_double_visitor_free(CLLVMDoubleVisitor *self);
// float
typedef struct CLLVMFloatVisitor CLLVMFloatVisitor;
SYMENGINE_EXPORT CLLVMFloatVisitor *llvm_float_visitor_new(void);
SYMENGINE_EXPORT void llvm_float_visitor_init(CLLVMFloatVisitor *self,
                                              const CVecBasic *args,
                                              const CVecBasic *exprs,
                                              int perform_cse, int opt_level);
SYMENGINE_EXPORT void llvm_float_visitor_call(CLLVMFloatVisitor *self,
                                              float *const outs,
                                              const float *const inps);
SYMENGINE_EXPORT void llvm_float_visitor_free(CLLVMFloatVisitor *self);
 
#ifdef SYMENGINE_HAVE_LLVM_LONG_DOUBLE
// long double
typedef struct CLLVMLongDoubleVisitor CLLVMLongDoubleVisitor;
SYMENGINE_EXPORT CLLVMLongDoubleVisitor *llvm_long_double_visitor_new(void);
SYMENGINE_EXPORT void
llvm_long_double_visitor_init(CLLVMLongDoubleVisitor *self,
                              const CVecBasic *args, const CVecBasic *exprs,
                              int perform_cse, int opt_level);
SYMENGINE_EXPORT void
llvm_long_double_visitor_call(CLLVMLongDoubleVisitor *self,
                              long double *const outs,
                              const long double *const inps);
SYMENGINE_EXPORT void
llvm_long_double_visitor_free(CLLVMLongDoubleVisitor *self);
#endif
#endif
 
SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cse(CVecBasic *replacement_syms,
                                                CVecBasic *replacement_exprs,
                                                CVecBasic *reduced_exprs,
                                                const CVecBasic *exprs);
 
SYMENGINE_EXPORT void symengine_print_stack_on_segfault(void);
 
#ifdef __cplusplus
}
#endif
#endif