@lakutata/math 0.0.0-stage → 3.1.3

package/vendor/symengine/symengine/cwrapper.h

@@ -0,0 +1,949 @@
+#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;
+
+//! Precision for code printers (ccode, cudacode, metalcode)
+typedef enum {
+    SYMENGINE_DOUBLE = 0,
+    SYMENGINE_FLOAT = 1,
+    SYMENGINE_HALF = 2,
+} BasicCodePrinterPrecision;
+//! Code printer settings object
+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;
+
+//! Struct to hold the real and imaginary parts of std::complex<double>
+//! extracted from basic
+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
+};
+
+//! 'basic' is internally implemented as a size 1 array of the type
+//  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;
+
+//! Basic is a struct to store the symbolic expressions
+//! It is declared as an array of size 1 to force reference semantics
+typedef basic_struct basic[1];
+
+//! Initialize a new basic instance. 's' is allocated on stack using the
+// '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);
+//! Free the C++ class wrapped by 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);
+
+//! Use these functions to get the commonly used constants as basic.
+
+//! Assigns to s a SymEngine constant with name c
+//! This function creates a new SymEngine::Constant from a copy of
+//! the string in c, thus the caller is free to use c afterwards,
+//! and also the caller must free c.
+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);
+
+//! Use these functions to get the use of positive, negative or unsigned
+//! infinity as basic.
+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);
+
+//! Use this function to get the use of Nan as basic.
+SYMENGINE_EXPORT void basic_const_nan(basic s);
+
+//! Assign value of b to a.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_assign(basic a, const basic b);
+
+//! Parse str and assign value to b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_parse(basic b, const char *str);
+//! Parse str and assign value to b, set convert_xor to > 0 for default usage,
+//! <= 0 otherwise.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_parse2(basic b, const char *str,
+                                                   int convert_xor);
+
+//! Returns the typeID of the basic struct
+SYMENGINE_EXPORT TypeID basic_get_type(const basic s);
+//! Returns the typeID of the class with the name c
+SYMENGINE_EXPORT TypeID basic_get_class_id(const char *c);
+//! Returns the class name of an object with the typeid `id`.
+//! The caller is responsible to free the string with 'basic_str_free'
+SYMENGINE_EXPORT char *basic_get_class_from_id(TypeID id);
+
+//! Assign to s, a symbol with string representation c.
+//! This function creates a new SymEngine::Symbol from a copy of
+//! the string in c, thus the caller is free to use c afterwards.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE symbol_set(basic s, const char *c);
+
+//! Returns 1 if s has value zero; 0 otherwise
+SYMENGINE_EXPORT int number_is_zero(const basic s);
+//! Returns 1 if s has negative value; 0 otherwise
+SYMENGINE_EXPORT int number_is_negative(const basic s);
+//! Returns 1 if s has positive value; 0 otherwise
+SYMENGINE_EXPORT int number_is_positive(const basic s);
+//! Returns 1 if s is complex; 0 otherwise
+SYMENGINE_EXPORT int number_is_complex(const basic s);
+
+//! Returns 1 if `e` contains the symbol `s`; 0 otherwise
+SYMENGINE_EXPORT int basic_has_symbol(const basic e, const basic s);
+
+//! Assign to s, a long.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_si(basic s, long i);
+//! Assign to s, a ulong.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_ui(basic s, unsigned long i);
+//! Assign to s, a mpz_t.
+#ifdef HAVE_SYMENGINE_GMP
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_mpz(basic s, const mpz_t i);
+#endif
+//! Assign to s, an integer that has base 10 representation c.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_set_str(basic s, const char *c);
+//! Assign to s, a real_double that has value of d.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_double_set_d(basic s, double d);
+//! Returns double value of s.
+SYMENGINE_EXPORT double real_double_get_d(const basic s);
+
+#ifdef HAVE_SYMENGINE_MPFR
+//! Assign to s, a real mpfr that has value d with precision prec.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set_d(basic s, double d,
+                                                      int prec);
+//! Assign to s, a real mpfr that has base 10 representation c with precision
+//! prec.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set_str(basic s, const char *c,
+                                                        int prec);
+//! Returns double value of s.
+SYMENGINE_EXPORT double real_mpfr_get_d(const basic s);
+//! Assign to s, a real mpfr that has value pointed by m.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_set(basic s, mpfr_srcptr m);
+//! Assign to m, the mpfr_t given in s.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE real_mpfr_get(mpfr_ptr m, const basic s);
+//! Returns the precision of the mpfr_t given by s.
+SYMENGINE_EXPORT mpfr_prec_t real_mpfr_get_prec(const basic s);
+#endif // HAVE_SYMENGINE_MPFR
+
+//! Assign to s, the real part of com
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_base_real_part(basic s,
+                                                             const basic com);
+//! Assign to s, the imaginary part of com
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+complex_base_imaginary_part(basic s, const basic com);
+
+//! Returns signed long value of s.
+SYMENGINE_EXPORT signed long integer_get_si(const basic s);
+//! Returns unsigned long value of s.
+SYMENGINE_EXPORT unsigned long integer_get_ui(const basic s);
+//! Returns s as a mpz_t.
+#ifdef HAVE_SYMENGINE_GMP
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE integer_get_mpz(mpz_t a, const basic s);
+#endif
+
+//! Assign to s, a rational i/j.
+//! Returns SYMENGINE_RUNTIME_ERROR if either i or j is not an integer.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set(basic s, const basic i,
+                                                   const basic j);
+//! Assign to s, a rational i/j, where i and j are signed longs.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_si(basic s, long i, long j);
+//! Assign to s, a rational i/j, where i and j are unsigned longs.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_ui(basic s, unsigned long i,
+                                                      unsigned long j);
+#ifdef HAVE_SYMENGINE_GMP
+//! Returns s as a mpq_t.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_get_mpq(mpq_t a, const basic s);
+//! Assign to s, a rational i, where is of type mpq_t.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE rational_set_mpq(basic s, const mpq_t i);
+#endif
+
+//! Assign to s, a complex re + i*im.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set(basic s, const basic re,
+                                                  const basic im);
+//! Assign to s, a complex re + i*im, where re and im are rationals.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set_rat(basic s, const basic re,
+                                                      const basic im);
+#ifdef HAVE_SYMENGINE_GMP
+//! Assign to s, a complex re + i*im, where re and im are of type mpq.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE complex_set_mpq(basic s, const mpq_t re,
+                                                      const mpq_t im);
+#endif
+
+//! Extract the real and imaginary doubles from the std::complex<double> stored
+//! in basic
+SYMENGINE_EXPORT dcomplex complex_double_get(const basic s);
+
+//! Assigns s = a + b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add(basic s, const basic a,
+                                                const basic b);
+//! Assigns s = a - b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sub(basic s, const basic a,
+                                                const basic b);
+//! Assigns s = a * b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul(basic s, const basic a,
+                                                const basic b);
+//! Assigns s = a / b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_div(basic s, const basic a,
+                                                const basic b);
+//! Assigns s = a ** b.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_pow(basic s, const basic a,
+                                                const basic b);
+//! Assign to s, derivative of expr with respect to sym.
+//! Returns SYMENGINE_RUNTIME_ERROR if sym is not a symbol.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_diff(basic s, const basic expr,
+                                                 const basic sym);
+//! Returns 1 if both basic are equal, 0 if not
+SYMENGINE_EXPORT int basic_eq(const basic a, const basic b);
+//! Returns 1 if both basic are not equal, 0 if they are
+SYMENGINE_EXPORT int basic_neq(const basic a, const basic b);
+
+//! Expands the expr a and assigns to s.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_expand(basic s, const basic a);
+//! Assigns s = -a.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_neg(basic s, const basic a);
+
+//! Assigns s = abs(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_abs(basic s, const basic a);
+
+//! Assigns s = erf(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_erf(basic s, const basic a);
+//! Assigns s = erfc(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_erfc(basic s, const basic a);
+
+//! Assigns s = sin(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sin(basic s, const basic a);
+//! Assigns s = cos(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cos(basic s, const basic a);
+//! Assigns s = tan(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_tan(basic s, const basic a);
+
+//! Assigns s = asin(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asin(basic s, const basic a);
+//! Assigns s = acos(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acos(basic s, const basic a);
+//! Assigns s = atan(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atan(basic s, const basic a);
+
+//! Assigns s = csc(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_csc(basic s, const basic a);
+//! Assigns s = sec(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sec(basic s, const basic a);
+//! Assigns s = cot(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cot(basic s, const basic a);
+
+//! Assigns s = acsc(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acsc(basic s, const basic a);
+//! Assigns s = asec(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asec(basic s, const basic a);
+//! Assigns s = acot(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acot(basic s, const basic a);
+
+//! Assigns s = sinh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sinh(basic s, const basic a);
+//! Assigns s = cosh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cosh(basic s, const basic a);
+//! Assigns s = tanh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_tanh(basic s, const basic a);
+
+//! Assigns s = asinh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asinh(basic s, const basic a);
+//! Assigns s = acosh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acosh(basic s, const basic a);
+//! Assigns s = atanh(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atanh(basic s, const basic a);
+
+//! Assigns s = csch(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_csch(basic s, const basic a);
+//! Assigns s = sech(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sech(basic s, const basic a);
+//! Assigns s = coth(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_coth(basic s, const basic a);
+
+//! Assigns s = acsch(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acsch(basic s, const basic a);
+//! Assigns s = asech(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_asech(basic s, const basic a);
+//! Assigns s = acoth(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_acoth(basic s, const basic a);
+
+//! Assigns s = lambertw(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_lambertw(basic s, const basic a);
+//! Assigns s = zeta(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_zeta(basic s, const basic a);
+//! Assigns s = dirichlet_eta(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_dirichlet_eta(basic s,
+                                                          const basic a);
+//! Assigns s = gamma(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_gamma(basic s, const basic a);
+//! Assigns s = loggamma(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_loggamma(basic s, const basic a);
+//! Assigns s = sqrt(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sqrt(basic s, const basic a);
+//! Assigns s = cbrt(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_cbrt(basic s, const basic a);
+//! Assigns s = exp(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_exp(basic s, const basic a);
+//! Assigns s = log(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_log(basic s, const basic a);
+//! Assigns s = floor(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_floor(basic s, const basic a);
+//! Assigns s = ceiling(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_ceiling(basic s, const basic a);
+//! Assigns s = sign(a).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_sign(basic s, const basic a);
+
+//! Assigns s = atan2(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_atan2(basic s, const basic a,
+                                                  const basic b);
+//! Assigns s = kronecker_delta(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_kronecker_delta(basic s,
+                                                            const basic a,
+                                                            const basic b);
+//! Assigns s = lowergamma(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_lowergamma(basic s, const basic a,
+                                                       const basic b);
+//! Assigns s = uppergamma(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_uppergamma(basic s, const basic a,
+                                                       const basic b);
+//! Assigns s = beta(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_beta(basic s, const basic a,
+                                                 const basic b);
+//! Assigns s = polygamma(a, b).
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_polygamma(basic s, const basic a,
+                                                      const basic b);
+
+//! Serialize an expression
+SYMENGINE_EXPORT char *basic_dumps(const basic s, unsigned long *size);
+//! Deserialize an expression
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_loads(basic s, const char *c,
+                                                  unsigned long size);
+
+//! Return a struct for holding code printer settings
+SYMENGINE_EXPORT BasicCodePrinterSettings *basic_code_printer_settings_new();
+//! Free a struct for holding code printer settings
+SYMENGINE_EXPORT void
+basic_code_printer_settings_free(BasicCodePrinterSettings *self);
+//! Set the precision in the code printer settings
+SYMENGINE_EXPORT void
+basic_code_printer_settings_set_precision(BasicCodePrinterSettings *self,
+                                          BasicCodePrinterPrecision prec);
+
+//! Returns a new char pointer to the string representation of s.
+SYMENGINE_EXPORT char *basic_str(const basic s);
+//! Returns a new char pointer to the string representation of s.
+//! Compatible with Julia
+SYMENGINE_EXPORT char *basic_str_julia(const basic s);
+//! Printing mathml
+SYMENGINE_EXPORT char *basic_str_mathml(const basic s);
+//! Printing latex string
+SYMENGINE_EXPORT char *basic_str_latex(const basic s);
+//! Printing C code
+SYMENGINE_EXPORT char *basic_str_ccode(const basic s);
+//! Printing C code with optional settings; NULL uses defaults
+SYMENGINE_EXPORT
+char *basic_str_ccode_settings(const basic s,
+                               const BasicCodePrinterSettings *settings);
+//! Printing CUDA code
+SYMENGINE_EXPORT char *basic_str_cudacode(const basic s);
+//! Printing CUDA code with optional settings; NULL uses defaults
+SYMENGINE_EXPORT
+char *basic_str_cudacode_settings(const basic s,
+                                  const BasicCodePrinterSettings *settings);
+//! Printing Metal code
+SYMENGINE_EXPORT char *basic_str_metalcode(const basic s);
+//! Printing Metal code with optional settings; NULL uses float defaults
+SYMENGINE_EXPORT char *
+basic_str_metalcode_settings(const basic s,
+                             const BasicCodePrinterSettings *settings);
+//! Printing JavaScript code
+SYMENGINE_EXPORT char *basic_str_jscode(const basic s);
+//! Frees the string s
+SYMENGINE_EXPORT void basic_str_free(char *s);
+
+//! Assign boolean true to s
+SYMENGINE_EXPORT void bool_set_true(basic s);
+//! Assign boolean false to s
+SYMENGINE_EXPORT void bool_set_false(basic s);
+
+//! Assign the empty set to s
+SYMENGINE_EXPORT void basic_set_emptyset(basic s);
+//! Assign the universal set to s
+SYMENGINE_EXPORT void basic_set_universalset(basic s);
+//! Assign the complexes to s
+SYMENGINE_EXPORT void basic_set_complexes(basic s);
+//! Assign the reals to s
+SYMENGINE_EXPORT void basic_set_reals(basic s);
+//! Assign the rationals to s
+SYMENGINE_EXPORT void basic_set_rationals(basic s);
+//! Assign the integers to s
+SYMENGINE_EXPORT void basic_set_integers(basic s);
+//! Assign an interval to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_interval(
+    basic s, const basic start, const basic end, int left_open, int right_open);
+//! Assign a finite set to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+basic_set_finiteset(basic s, const CSetBasic *container);
+//! Assign the union of a and b to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_union(basic s, const basic a,
+                                                      const basic b);
+//! Assign the intersection of a and b to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_intersection(basic s,
+                                                             const basic a,
+                                                             const basic b);
+//! Assign the complement of a with respect to b to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_complement(basic s,
+                                                           const basic a,
+                                                           const basic b);
+//! Assign the whether a contains of b to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_contains(basic s, const basic a,
+                                                         const basic b);
+//! Is a a subset of b
+SYMENGINE_EXPORT int basic_set_is_subset(const basic a, const basic b);
+//! Is a a proper subset of b
+SYMENGINE_EXPORT int basic_set_is_proper_subset(const basic a, const basic b);
+//! Is a a superset of b
+SYMENGINE_EXPORT int basic_set_is_superset(const basic a, const basic b);
+//! Is a a proper superset of b
+SYMENGINE_EXPORT int basic_set_is_proper_superset(const basic a, const basic b);
+//! Assign the infimum of a to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_inf(basic s, const basic a);
+//! Assign the supremum of a to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_sup(basic s, const basic a);
+//! Assign the boundary of a to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_boundary(basic s,
+                                                         const basic a);
+//! Assign the interior of a to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_interior(basic s,
+                                                         const basic a);
+//! Assign the closure of a to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_set_closure(basic s, const basic a);
+
+//! Returns 1 if a specific component is installed and 0 if not.
+//! Component can be "mpfr", "flint", "arb", "mpc", "ecm", "primesieve",
+//! "piranha", "boost", "pthread", "llvm" or "llvm_long_double" (all in
+//! lowercase).
+//! This function, using string comparison, was implemented for particular
+//! libraries that do not provide header access (i.e. SymEngine.jl
+//! and other related shared libraries).
+//! Avoid usage while having access to the headers. Instead simply use
+//! HAVE_SYMENGINE_MPFR and other related macros directly.
+SYMENGINE_EXPORT int symengine_have_component(const char *c);
+
+//! Return 1 if s is a Number, 0 if not.
+SYMENGINE_EXPORT int is_a_Number(const basic s);
+//! Return 1 if s is an Integer, 0 if not.
+SYMENGINE_EXPORT int is_a_Integer(const basic s);
+//! Return 1 if s is a Rational, 0 if not.
+SYMENGINE_EXPORT int is_a_Rational(const basic s);
+//! Return 1 if s is a Symbol, 0 if not.
+SYMENGINE_EXPORT int is_a_Symbol(const basic s);
+//! Return 1 if s is a Complex, 0 if not.
+SYMENGINE_EXPORT int is_a_Complex(const basic s);
+//! Return 1 if c is a RealDouble, 0 if not.
+SYMENGINE_EXPORT int is_a_RealDouble(const basic c);
+//! Return 1 if c is a ComplexDouble, 0 if not.
+SYMENGINE_EXPORT int is_a_ComplexDouble(const basic c);
+//! Return 1 if c is a RealMPFR, 0 if not.
+SYMENGINE_EXPORT int is_a_RealMPFR(const basic c);
+//! Return 1 if c is a ComplexMPC, 0 if not.
+SYMENGINE_EXPORT int is_a_ComplexMPC(const basic c);
+//! Return 1 if c is a Set, 0 if not.
+SYMENGINE_EXPORT int is_a_Set(const basic c);
+
+//! Wrapper for std::vector<int>
+
+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);
+
+//! Wrapper for vec_basic
+
+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);
+
+//! Assigns to s the max of the provided args.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_max(basic s, const CVecBasic *d);
+//! Assigns to s the min of the provided args.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_min(basic s, const CVecBasic *d);
+//! Adds together all the values in a vector
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add_vec(basic s,
+                                                    const CVecBasic *d);
+
+//! Multiples all the values in a vector
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul_vec(basic s,
+                                                    const CVecBasic *d);
+
+//! Wrappers for Matrices
+
+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);
+//! Return a DenseMatrix with l's elements
+SYMENGINE_EXPORT CDenseMatrix *
+dense_matrix_new_vec(unsigned rows, unsigned cols, CVecBasic *l);
+//! Return a DenseMatrix with r rows and c columns
+SYMENGINE_EXPORT CDenseMatrix *dense_matrix_new_rows_cols(unsigned r,
+                                                          unsigned c);
+
+SYMENGINE_EXPORT void sparse_matrix_free(CSparseMatrix *self);
+
+//! Assign to s, a DenseMatrix with value d
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_set(CDenseMatrix *s,
+                                                       const CDenseMatrix *d);
+
+//! Return a string representation of s.
+//! The caller is responsible to free the string with 'basic_str_free'
+SYMENGINE_EXPORT char *dense_matrix_str(const CDenseMatrix *s);
+//! Resize mat to rxc
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_rows_cols(CDenseMatrix *mat,
+                                                             unsigned r,
+                                                             unsigned c);
+//! Assign to s, mat[r][c]
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_get_basic(
+    basic s, const CDenseMatrix *mat, unsigned long int r, unsigned long int c);
+//! Assign s to mat[r][c]
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_set_basic(
+    CDenseMatrix *mat, unsigned long int r, unsigned long int c, basic s);
+//! Assign to s, mat[r][c]
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+sparse_matrix_get_basic(basic s, const CSparseMatrix *mat, unsigned long int r,
+                        unsigned long int c);
+//! Assign s to mat[r][c]
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE sparse_matrix_set_basic(
+    CSparseMatrix *mat, unsigned long int r, unsigned long int c, basic s);
+//! Assign to s, determinent of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_det(basic s,
+                                                       const CDenseMatrix *mat);
+//! Assign to s, a DenseMatrix which is the inverse of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_inv(CDenseMatrix *s,
+                                                       const CDenseMatrix *mat);
+//! Assign to s, a DenseMatrix which is the transpose of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+dense_matrix_transpose(CDenseMatrix *s, const CDenseMatrix *mat);
+//! Assign to s, a SubMatrix of mat, starting with [r1, r2] until [r2, c2], with
+//! step sizes [r, c]
+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);
+//! The matrix which results from joining the rows of A and B
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+dense_matrix_row_join(CDenseMatrix *A, const CDenseMatrix *B);
+//! The matrix which results from joining the columns of A and B
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+dense_matrix_col_join(CDenseMatrix *A, const CDenseMatrix *B);
+//! Delete a specific row of the matrix
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_row_del(CDenseMatrix *C,
+                                                           unsigned k);
+//! Delete a specific column of the matrix
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_col_del(CDenseMatrix *C,
+                                                           unsigned k);
+
+//! Return the number of columns of s
+SYMENGINE_EXPORT unsigned long int dense_matrix_cols(const CDenseMatrix *s);
+//! Return the number of rows of s
+SYMENGINE_EXPORT unsigned long int dense_matrix_rows(const CDenseMatrix *s);
+//! Assign to s, the addition of matA and matB
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_add_matrix(
+    CDenseMatrix *s, const CDenseMatrix *matA, const CDenseMatrix *matB);
+//! Assign to s, the matrix multiplication of matA and matB
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_mul_matrix(
+    CDenseMatrix *s, const CDenseMatrix *matA, const CDenseMatrix *matB);
+//! Assign to s, the addition of scalar b to matrix matA
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_add_scalar(
+    CDenseMatrix *s, const CDenseMatrix *matA, const basic b);
+//! Assign to s, the multiplication of scalar b to matrix matA
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_mul_scalar(
+    CDenseMatrix *s, const CDenseMatrix *matA, const basic b);
+//! Assign to l and u, LU factorization of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LU(CDenseMatrix *l,
+                                                      CDenseMatrix *u,
+                                                      const CDenseMatrix *mat);
+//! Assign to l and d, LDL factorization of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LDL(CDenseMatrix *l,
+                                                       CDenseMatrix *d,
+                                                       const CDenseMatrix *mat);
+//! Assign to lu, fraction free LU factorization of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE
+dense_matrix_FFLU(CDenseMatrix *lu, const CDenseMatrix *mat);
+//! Assign to l, d and u, FFLDU factorization of mat
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_FFLDU(
+    CDenseMatrix *l, CDenseMatrix *d, CDenseMatrix *u, const CDenseMatrix *mat);
+//! Assign to x, solution to A x = b
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_LU_solve(
+    CDenseMatrix *x, const CDenseMatrix *A, const CDenseMatrix *b);
+//! Assign to s, a matrix of ones of size rxc
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_ones(CDenseMatrix *s,
+                                                        unsigned long int r,
+                                                        unsigned long int c);
+//! Assign to s, a matrix of zeros of size rxc
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_zeros(CDenseMatrix *s,
+                                                         unsigned long int r,
+                                                         unsigned long int c);
+//! Assign to s, a diagonal matrix with a diagonal at offset k, with elements in
+//! d
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_diag(CDenseMatrix *s,
+                                                        CVecBasic *d,
+                                                        long int k);
+//! Assign to s, a matrix of size NxM, with diagonal of 1s at offset k
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_eye(CDenseMatrix *s,
+                                                       unsigned long int N,
+                                                       unsigned long int M,
+                                                       int k);
+//! Assign to result, elementwise derivative of A with respect to x. Returns 0
+//! on success.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_diff(CDenseMatrix *result,
+                                                        const CDenseMatrix *A,
+                                                        basic const x);
+//! Assign to result, jacobian of A with respect to x. Returns 0 on success.
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE dense_matrix_jacobian(
+    CDenseMatrix *result, const CDenseMatrix *A, const CDenseMatrix *x);
+
+//! Assign to s, a CSRMatrix
+SYMENGINE_EXPORT void sparse_matrix_init(CSparseMatrix *s);
+//! Assign to s, a CSRMatrix with r rows and c columns
+SYMENGINE_EXPORT void sparse_matrix_rows_cols(CSparseMatrix *s,
+                                              unsigned long int r,
+                                              unsigned long int c);
+//! Return a string representation of s
+SYMENGINE_EXPORT char *sparse_matrix_str(const CSparseMatrix *s);
+
+//! Return 1 if c is a DenseMatrix, 0 if not.
+SYMENGINE_EXPORT int is_a_DenseMatrix(const CDenseMatrix *c);
+//! Return 1 if c is a SparseMatrix, 0 if not.
+SYMENGINE_EXPORT int is_a_SparseMatrix(const CSparseMatrix *c);
+
+//! Return 1 if lhs == rhs, 0 if not
+SYMENGINE_EXPORT int dense_matrix_eq(CDenseMatrix *lhs, CDenseMatrix *rhs);
+//! Return 1 if lhs == rhs, 0 if not
+SYMENGINE_EXPORT int sparse_matrix_eq(CSparseMatrix *lhs, CSparseMatrix *rhs);
+
+//! Wrapper for set_basic
+
+SYMENGINE_EXPORT CSetBasic *setbasic_new(void);
+SYMENGINE_EXPORT void setbasic_free(CSetBasic *self);
+//! Returns 1 if insert is successful and 0 if set already contains the value
+//! and insertion is unsuccessful
+SYMENGINE_EXPORT int setbasic_insert(CSetBasic *self, const basic value);
+SYMENGINE_EXPORT void setbasic_get(CSetBasic *self, int n, basic result);
+//! Returns 1 if value is found in the set and 0 if not
+SYMENGINE_EXPORT int setbasic_find(CSetBasic *self, basic value);
+//! Returns 1 if value was erased from the set and 0 if not
+SYMENGINE_EXPORT int setbasic_erase(CSetBasic *self, const basic value);
+SYMENGINE_EXPORT size_t setbasic_size(CSetBasic *self);
+
+//! Wrapper for map_basic_basic
+
+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);
+//! Returns 1 if such a key exists in the map and get is successful, 0 if not
+SYMENGINE_EXPORT int mapbasicbasic_get(CMapBasicBasic *self, const basic key,
+                                       basic mapped);
+SYMENGINE_EXPORT size_t mapbasicbasic_size(CMapBasicBasic *self);
+
+// -------------------------------------
+
+//! Returns a CVecBasic of vec_basic given by get_args
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_get_args(const basic self,
+                                                     CVecBasic *args);
+//! Returns a CSetBasic of set_basic given by free_symbols
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_free_symbols(const basic self,
+                                                         CSetBasic *symbols);
+//! Returns a CSetBasic of set_basic given by function_symbols
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_function_symbols(CSetBasic *symbols,
+                                                             const basic self);
+//! returns the hash of the Basic object
+SYMENGINE_EXPORT size_t basic_hash(const basic self);
+//! substitutes all the keys with their mapped values
+//! in the given basic `e` and returns it through basic 's'
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_subs(basic s, const basic e,
+                                                 const CMapBasicBasic *mapbb);
+//! substitutes a basic 'a' with another basic 'b',
+//! in the given basic 'e' and returns it through basic 's'
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_subs2(basic s, const basic e,
+                                                  const basic a, const basic b);
+
+//! Assigns to s a FunctionSymbol with name described by c, with dependent
+//! symbols arg
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE function_symbol_set(basic s,
+                                                          const char *c,
+                                                          const CVecBasic *arg);
+//! Returns the name of the given FunctionSymbol.
+//! The caller is responsible to free the string with 'basic_str_free'
+SYMENGINE_EXPORT char *function_symbol_get_name(const basic b);
+//! Returns the coefficient of x^n in b
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_coeff(basic c, const basic b,
+                                                  const basic x, const basic n);
+
+//! Wrapper for solve.h
+
+//! Solves the system of linear equations given by sys
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE vecbasic_linsolve(CVecBasic *sol,
+                                                        const CVecBasic *sys,
+                                                        const CVecBasic *sym);
+//! Solves polynomial equation f if the set of solutions is finite
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_solve_poly(CSetBasic *r,
+                                                       const basic f,
+                                                       const basic s);
+
+//! Wrapper for ascii_art()
+
+//! Returns a new char pointer to the ascii_art string
+//! The caller is responsible to free the pointer using 'basic_str_free'.
+SYMENGINE_EXPORT char *ascii_art_str(void);
+
+//! Wrapper for ntheory
+//! Greatest Common Divisor
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_gcd(basic s, const basic a,
+                                                  const basic b);
+//! Least Common Multiple
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lcm(basic s, const basic a,
+                                                  const basic b);
+//! Extended GCD
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_gcd_ext(basic g, basic s, basic t,
+                                                      const basic a,
+                                                      const basic b);
+//! \return next prime after `a`
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_nextprime(basic s, const basic a);
+//! modulo round toward zero
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_mod(basic s, const basic n,
+                                                  const basic d);
+//! \return quotient round toward zero when `n` is divided by `d`
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient(basic s, const basic n,
+                                                       const basic d);
+//! \return modulo and quotient round toward zero
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_mod(basic q, basic r,
+                                                           const basic n,
+                                                           const basic d);
+//! modulo round toward -inf
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_mod_f(basic s, const basic n,
+                                                    const basic d);
+//! \return quotient round toward -inf when `n` is divided by `d`
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_f(basic s, const basic n,
+                                                         const basic d);
+//! \return modulo and quotient round toward -inf
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_quotient_mod_f(basic q, basic r,
+                                                             const basic n,
+                                                             const basic d);
+//! inverse modulo
+SYMENGINE_EXPORT int ntheory_mod_inverse(basic b, const basic a, const basic m);
+//! nth Fibonacci number //  fibonacci(0) = 0 and fibonacci(1) = 1
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_fibonacci(basic s,
+                                                        unsigned long a);
+//! Fibonacci n and n-1
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_fibonacci2(basic g, basic s,
+                                                         unsigned long a);
+//! Lucas number
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lucas(basic s, unsigned long a);
+//! Lucas number n and n-1
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_lucas2(basic g, basic s,
+                                                     unsigned long a);
+//! Binomial Coefficient
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_binomial(basic s, const basic a,
+                                                       unsigned long b);
+//! Factorial
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE ntheory_factorial(basic s,
+                                                        unsigned long n);
+//! Evaluate b and assign the value to s
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_evalf(basic s, const basic b,
+                                                  unsigned long bits, int real);
+
+//! Wrapper for as_numer_denom
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_as_numer_denom(basic numer,
+                                                           basic denom,
+                                                           const basic x);
+//! Wrapper for as_two_terms for expressions of type Add
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_add_as_two_terms(basic term1,
+                                                             basic term2,
+                                                             const basic s);
+//! Wrapper for as_two_terms for expressions of type Mul
+SYMENGINE_EXPORT CWRAPPER_OUTPUT_TYPE basic_mul_as_two_terms(basic term1,
+                                                             basic term2,
+                                                             const basic s);
+
+//! Wrapper for LambdaRealDoubleVisitor
+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);
+
+//! Wrapper for LambdaRealDoubleVisitor
+#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);
+
+//! Print stacktrace on segfault
+SYMENGINE_EXPORT void symengine_print_stack_on_segfault(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif