# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_c3')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_c3')
    _c3 = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_c3', [dirname(__file__)])
        except ImportError:
            import _c3
            return _c3
        try:
            _mod = imp.load_module('_c3', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _c3 = swig_import_helper()
    del swig_import_helper
else:
    import _c3
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def c3py_wrapped_eval(N: 'size_t', x: 'double const *', out: 'double *', args: 'void *') -> "int":
    return _c3.c3py_wrapped_eval(N, x, out, args)
c3py_wrapped_eval = _c3.c3py_wrapped_eval

def fwrap_set_pyfunc(arg1: 'struct Fwrap *', arg2: 'PyObject *') -> "void":
    return _c3.fwrap_set_pyfunc(arg1, arg2)
fwrap_set_pyfunc = _c3.fwrap_set_pyfunc

def function_train_alloc(arg1: 'size_t') -> "struct FunctionTrain *":
    return _c3.function_train_alloc(arg1)
function_train_alloc = _c3.function_train_alloc

def function_train_free(arg1: 'FunctionTrain') -> "void":
    return _c3.function_train_free(arg1)
function_train_free = _c3.function_train_free

def ft_regress_run(ftr: 'struct FTRegress *', opt: 'struct c3Opt *', len1: 'size_t', len2: 'size_t') -> "struct FunctionTrain *":
    return _c3.ft_regress_run(ftr, opt, len1, len2)
ft_regress_run = _c3.ft_regress_run

def cross_validate_init(dim: 'size_t', len1: 'size_t', len2: 'size_t', kfold: 'size_t', verbose: 'int') -> "struct CrossValidate *":
    return _c3.cross_validate_init(dim, len1, len2, kfold, verbose)
cross_validate_init = _c3.cross_validate_init

def lin_elem_exp_aopts_alloc(len1: 'size_t') -> "struct LinElemExpAopts *":
    return _c3.lin_elem_exp_aopts_alloc(len1)
lin_elem_exp_aopts_alloc = _c3.lin_elem_exp_aopts_alloc

def function_train_eval(ft: 'FunctionTrain', len1: 'size_t') -> "double":
    return _c3.function_train_eval(ft, len1)
function_train_eval = _c3.function_train_eval

def function_train_gradient_eval(ft: 'FunctionTrain', len1: 'size_t', len2: 'size_t') -> "void":
    return _c3.function_train_gradient_eval(ft, len1, len2)
function_train_gradient_eval = _c3.function_train_gradient_eval
CROSS = _c3.CROSS
REGRESS = _c3.REGRESS
C3UNSPEC = _c3.C3UNSPEC

def c3approx_create(arg1: 'enum C3ATYPE', arg2: 'size_t') -> "struct C3Approx *":
    return _c3.c3approx_create(arg1, arg2)
c3approx_create = _c3.c3approx_create

def c3approx_destroy(arg1: 'struct C3Approx *') -> "void":
    return _c3.c3approx_destroy(arg1)
c3approx_destroy = _c3.c3approx_destroy

def c3approx_set_approx_opts_dim(arg1: 'struct C3Approx *', arg2: 'size_t', arg3: 'OneApproxOpts') -> "void":
    return _c3.c3approx_set_approx_opts_dim(arg1, arg2, arg3)
c3approx_set_approx_opts_dim = _c3.c3approx_set_approx_opts_dim

def c3approx_set_opt_opts_dim(arg1: 'struct C3Approx *', arg2: 'size_t', arg3: 'void *') -> "void":
    return _c3.c3approx_set_opt_opts_dim(arg1, arg2, arg3)
c3approx_set_opt_opts_dim = _c3.c3approx_set_opt_opts_dim

def c3approx_set_round_tol(arg1: 'struct C3Approx *', arg2: 'double') -> "void":
    return _c3.c3approx_set_round_tol(arg1, arg2)
c3approx_set_round_tol = _c3.c3approx_set_round_tol

def c3approx_set_verbose(arg1: 'struct C3Approx *', arg2: 'int') -> "void":
    return _c3.c3approx_set_verbose(arg1, arg2)
c3approx_set_verbose = _c3.c3approx_set_verbose

def c3approx_init_cross(c3a: 'struct C3Approx *', arg2: 'size_t', arg3: 'int', arg4: 'double **') -> "void":
    return _c3.c3approx_init_cross(c3a, arg2, arg3, arg4)
c3approx_init_cross = _c3.c3approx_init_cross

def c3approx_set_cross_tol(arg1: 'struct C3Approx *', arg2: 'double') -> "void":
    return _c3.c3approx_set_cross_tol(arg1, arg2)
c3approx_set_cross_tol = _c3.c3approx_set_cross_tol

def c3approx_set_adapt_kickrank(arg1: 'struct C3Approx *', arg2: 'size_t') -> "void":
    return _c3.c3approx_set_adapt_kickrank(arg1, arg2)
c3approx_set_adapt_kickrank = _c3.c3approx_set_adapt_kickrank

def c3approx_set_adapt_maxrank_all(arg1: 'struct C3Approx *', arg2: 'size_t') -> "void":
    return _c3.c3approx_set_adapt_maxrank_all(arg1, arg2)
c3approx_set_adapt_maxrank_all = _c3.c3approx_set_adapt_maxrank_all

def c3approx_set_cross_maxiter(arg1: 'struct C3Approx *', arg2: 'size_t') -> "void":
    return _c3.c3approx_set_cross_maxiter(arg1, arg2)
c3approx_set_cross_maxiter = _c3.c3approx_set_cross_maxiter

def c3approx_do_cross(arg1: 'struct C3Approx *', arg2: 'struct Fwrap *', arg3: 'int') -> "struct FunctionTrain *":
    return _c3.c3approx_do_cross(arg1, arg2, arg3)
c3approx_do_cross = _c3.c3approx_do_cross

def c3approx_get_approx_args(arg1: 'struct C3Approx const *') -> "struct MultiApproxOpts *":
    return _c3.c3approx_get_approx_args(arg1)
c3approx_get_approx_args = _c3.c3approx_get_approx_args

def c3approx_get_dim(arg1: 'struct C3Approx const *') -> "size_t":
    return _c3.c3approx_get_dim(arg1)
c3approx_get_dim = _c3.c3approx_get_dim

def calloc_double(arg1: 'size_t const') -> "double *":
    return _c3.calloc_double(arg1)
calloc_double = _c3.calloc_double

def malloc_dd(arg1: 'size_t const') -> "double **":
    return _c3.malloc_dd(arg1)
malloc_dd = _c3.malloc_dd

def calloc_int(arg1: 'size_t const') -> "int *":
    return _c3.calloc_int(arg1)
calloc_int = _c3.calloc_int

def calloc_size_t(arg1: 'size_t const') -> "size_t *":
    return _c3.calloc_size_t(arg1)
calloc_size_t = _c3.calloc_size_t

def copy_dd(arg1: 'size_t', arg2: 'size_t', arg3: 'double **', arg4: 'double **') -> "void":
    return _c3.copy_dd(arg1, arg2, arg3, arg4)
copy_dd = _c3.copy_dd

def free_dd(N: 'size_t', arr: 'double **') -> "void":
    return _c3.free_dd(N, arr)
free_dd = _c3.free_dd

def dones(arg1: 'size_t const') -> "double *":
    return _c3.dones(arg1)
dones = _c3.dones

def drandu(arg1: 'size_t const') -> "double *":
    return _c3.drandu(arg1)
drandu = _c3.drandu

def darray_val(arg1: 'size_t const', arg2: 'double') -> "double *":
    return _c3.darray_val(arg1, arg2)
darray_val = _c3.darray_val

def dzeros(arg1: 'size_t const') -> "double *":
    return _c3.dzeros(arg1)
dzeros = _c3.dzeros

def izeros(arg1: 'size_t const') -> "int *":
    return _c3.izeros(arg1)
izeros = _c3.izeros

def dprod(arg1: 'size_t const', arg2: 'double const *') -> "double":
    return _c3.dprod(arg1, arg2)
dprod = _c3.dprod

def iprod(arg1: 'size_t const', arg2: 'int const *') -> "int":
    return _c3.iprod(arg1, arg2)
iprod = _c3.iprod

def iprod_sz(arg1: 'size_t const', arg2: 'size_t const *') -> "size_t":
    return _c3.iprod_sz(arg1, arg2)
iprod_sz = _c3.iprod_sz

def dprint(arg1: 'size_t const', arg2: 'double const *') -> "void":
    return _c3.dprint(arg1, arg2)
dprint = _c3.dprint

def dprint2d(arg1: 'size_t const', arg2: 'size_t const', arg3: 'double const *') -> "void":
    return _c3.dprint2d(arg1, arg2, arg3)
dprint2d = _c3.dprint2d

def dprint2dd(arg1: 'size_t const', arg2: 'size_t const', arg3: 'double **') -> "void":
    return _c3.dprint2dd(arg1, arg2, arg3)
dprint2dd = _c3.dprint2dd

def dprint2d_col(arg1: 'size_t const', arg2: 'size_t const', arg3: 'double const *') -> "void":
    return _c3.dprint2d_col(arg1, arg2, arg3)
dprint2d_col = _c3.dprint2d_col

def iprint(arg1: 'size_t const', arg2: 'int const *') -> "void":
    return _c3.iprint(arg1, arg2)
iprint = _c3.iprint

def iprint_sz(arg1: 'size_t const', arg2: 'size_t const *') -> "void":
    return _c3.iprint_sz(arg1, arg2)
iprint_sz = _c3.iprint_sz

def linspace(arg1: 'double const', arg2: 'double const', arg3: 'size_t const') -> "double *":
    return _c3.linspace(arg1, arg2, arg3)
linspace = _c3.linspace

def dd_row_linspace(arg1: 'double **', arg2: 'size_t', arg3: 'double', arg4: 'double', arg5: 'size_t') -> "void":
    return _c3.dd_row_linspace(arg1, arg2, arg3, arg4, arg5)
dd_row_linspace = _c3.dd_row_linspace

def logspace(arg1: 'int', arg2: 'int', arg3: 'size_t const') -> "double *":
    return _c3.logspace(arg1, arg2, arg3)
logspace = _c3.logspace

def arange(arg1: 'double const', arg2: 'double const', arg3: 'double const', arg4: 'size_t *') -> "double *":
    return _c3.arange(arg1, arg2, arg3, arg4)
arange = _c3.arange

def diag(arg1: 'size_t const', arg2: 'double *') -> "double *":
    return _c3.diag(arg1, arg2)
diag = _c3.diag

def dconcat_cols(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double *', arg5: 'double *') -> "double *":
    return _c3.dconcat_cols(arg1, arg2, arg3, arg4, arg5)
dconcat_cols = _c3.dconcat_cols

def serialize_double_to_text(arg1: 'double') -> "char *":
    return _c3.serialize_double_to_text(arg1)
serialize_double_to_text = _c3.serialize_double_to_text

def deserialize_double_from_text(arg1: 'char *') -> "double":
    return _c3.deserialize_double_from_text(arg1)
deserialize_double_from_text = _c3.deserialize_double_from_text

def serialize_darray_to_text(arg1: 'size_t', arg2: 'double const *') -> "char *":
    return _c3.serialize_darray_to_text(arg1, arg2)
serialize_darray_to_text = _c3.serialize_darray_to_text

def deserialize_darray_from_text(arg1: 'char *', arg2: 'size_t *') -> "double *":
    return _c3.deserialize_darray_from_text(arg1, arg2)
deserialize_darray_from_text = _c3.deserialize_darray_from_text

def serialize_double_packed(arg1: 'double') -> "char *":
    return _c3.serialize_double_packed(arg1)
serialize_double_packed = _c3.serialize_double_packed

def deserialize_double_packed(arg1: 'char *') -> "double":
    return _c3.deserialize_double_packed(arg1)
deserialize_double_packed = _c3.deserialize_double_packed

def serialize_double_arr_packed(arg1: 'size_t', arg2: 'double const *') -> "char *":
    return _c3.serialize_double_arr_packed(arg1, arg2)
serialize_double_arr_packed = _c3.serialize_double_arr_packed

def darray_save(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'char *', arg5: 'int') -> "int":
    return _c3.darray_save(arg1, arg2, arg3, arg4, arg5)
darray_save = _c3.darray_save

def darray_load(arg1: 'char *', arg2: 'int') -> "double *":
    return _c3.darray_load(arg1, arg2)
darray_load = _c3.darray_load
class c3Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, c3Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, c3Vector, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _c3.c3Vector_size_set
    __swig_getmethods__["size"] = _c3.c3Vector_size_get
    if _newclass:
        size = _swig_property(_c3.c3Vector_size_get, _c3.c3Vector_size_set)
    __swig_setmethods__["elem"] = _c3.c3Vector_elem_set
    __swig_getmethods__["elem"] = _c3.c3Vector_elem_get
    if _newclass:
        elem = _swig_property(_c3.c3Vector_elem_get, _c3.c3Vector_elem_set)

    def __init__(self):
        this = _c3.new_c3Vector()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_c3Vector
    __del__ = lambda self: None
c3Vector_swigregister = _c3.c3Vector_swigregister
c3Vector_swigregister(c3Vector)


def c3vector_alloc(arg1: 'size_t', xdata: 'double const *') -> "struct c3Vector *":
    return _c3.c3vector_alloc(arg1, xdata)
c3vector_alloc = _c3.c3vector_alloc

def c3vector_copy(arg1: 'c3Vector') -> "struct c3Vector *":
    return _c3.c3vector_copy(arg1)
c3vector_copy = _c3.c3vector_copy

def c3vector_free(arg1: 'c3Vector') -> "void":
    return _c3.c3vector_free(arg1)
c3vector_free = _c3.c3vector_free

def c3vector_array_alloc(arg1: 'size_t') -> "struct c3Vector **":
    return _c3.c3vector_array_alloc(arg1)
c3vector_array_alloc = _c3.c3vector_array_alloc

def c3vector_array_copy(arg1: 'size_t', arg2: 'struct c3Vector **') -> "struct c3Vector **":
    return _c3.c3vector_array_copy(arg1, arg2)
c3vector_array_copy = _c3.c3vector_array_copy

def c3vector_array_free(arg1: 'size_t', arg2: 'struct c3Vector **') -> "void":
    return _c3.c3vector_array_free(arg1, arg2)
c3vector_array_free = _c3.c3vector_array_free

def randu() -> "double":
    return _c3.randu()
randu = _c3.randu

def randn() -> "double":
    return _c3.randn()
randn = _c3.randn

def poisson(arg1: 'double') -> "size_t":
    return _c3.poisson(arg1)
poisson = _c3.poisson

def strip_ends(strin: 'char *', arg2: 'char', arg3: 'char') -> "void":
    return _c3.strip_ends(strin, arg2, arg3)
strip_ends = _c3.strip_ends

def strip_blank_ends(arg1: 'char *') -> "void":
    return _c3.strip_blank_ends(arg1)
strip_blank_ends = _c3.strip_blank_ends

def bite_string(arg1: 'char *', arg2: 'char') -> "char *":
    return _c3.bite_string(arg1, arg2)
bite_string = _c3.bite_string

def bite_string2(arg1: 'char *', arg2: 'char *') -> "char *":
    return _c3.bite_string2(arg1, arg2)
bite_string2 = _c3.bite_string2

def parse_string(arg1: 'char *', arg2: 'char', arg3: 'size_t *') -> "char **":
    return _c3.parse_string(arg1, arg2, arg3)
parse_string = _c3.parse_string

def concat_string(arg1: 'char *', arg2: 'char *') -> "char *":
    return _c3.concat_string(arg1, arg2)
concat_string = _c3.concat_string

def concat_string_ow(arg1: 'char **', arg2: 'char *') -> "void":
    return _c3.concat_string_ow(arg1, arg2)
concat_string_ow = _c3.concat_string_ow

def itoa(value: 'int', result: 'char *', base: 'int') -> "char *":
    return _c3.itoa(value, result, base)
itoa = _c3.itoa

def serialize_char(arg1: 'unsigned char *', arg2: 'char') -> "unsigned char *":
    return _c3.serialize_char(arg1, arg2)
serialize_char = _c3.serialize_char

def serialize_int(arg1: 'unsigned char *', arg2: 'int') -> "unsigned char *":
    return _c3.serialize_int(arg1, arg2)
serialize_int = _c3.serialize_int

def deserialize_int(arg1: 'unsigned char *', arg2: 'int *') -> "unsigned char *":
    return _c3.deserialize_int(arg1, arg2)
deserialize_int = _c3.deserialize_int

def serialize_size_t(arg1: 'unsigned char *', arg2: 'size_t') -> "unsigned char *":
    return _c3.serialize_size_t(arg1, arg2)
serialize_size_t = _c3.serialize_size_t

def deserialize_size_t(arg1: 'unsigned char *', arg2: 'size_t *') -> "unsigned char *":
    return _c3.deserialize_size_t(arg1, arg2)
deserialize_size_t = _c3.deserialize_size_t

def serialize_double(arg1: 'unsigned char *', arg2: 'double') -> "unsigned char *":
    return _c3.serialize_double(arg1, arg2)
serialize_double = _c3.serialize_double

def deserialize_double(arg1: 'unsigned char *', arg2: 'double *') -> "unsigned char *":
    return _c3.deserialize_double(arg1, arg2)
deserialize_double = _c3.deserialize_double

def serialize_doublep(arg1: 'unsigned char *', arg2: 'double *', arg3: 'size_t') -> "unsigned char *":
    return _c3.serialize_doublep(arg1, arg2, arg3)
serialize_doublep = _c3.serialize_doublep

def deserialize_doublep(arg1: 'unsigned char *', arg2: 'double **', arg3: 'size_t *') -> "unsigned char *":
    return _c3.deserialize_doublep(arg1, arg2, arg3)
deserialize_doublep = _c3.deserialize_doublep

def readtxt_double_array(arg1: 'char *', arg2: 'size_t *', arg3: 'size_t *') -> "double *":
    return _c3.readtxt_double_array(arg1, arg2, arg3)
readtxt_double_array = _c3.readtxt_double_array

def readfile_double_array(arg1: 'FILE *', arg2: 'size_t *', arg3: 'size_t *') -> "double *":
    return _c3.readfile_double_array(arg1, arg2, arg3)
readfile_double_array = _c3.readfile_double_array

def ft_regress_alloc(dim: 'size_t', arg2: 'struct MultiApproxOpts *', ranks: 'size_t *') -> "struct FTRegress *":
    return _c3.ft_regress_alloc(dim, arg2, ranks)
ft_regress_alloc = _c3.ft_regress_alloc

def ft_regress_set_sample_weights(arg1: 'struct FTRegress const *', arg2: 'double const *') -> "void":
    return _c3.ft_regress_set_sample_weights(arg1, arg2)
ft_regress_set_sample_weights = _c3.ft_regress_set_sample_weights

def ft_regress_get_dim(arg1: 'struct FTRegress const *') -> "size_t":
    return _c3.ft_regress_get_dim(arg1)
ft_regress_get_dim = _c3.ft_regress_get_dim

def ft_regress_set_adapt(arg1: 'struct FTRegress *', arg2: 'int') -> "void":
    return _c3.ft_regress_set_adapt(arg1, arg2)
ft_regress_set_adapt = _c3.ft_regress_set_adapt

def ft_regress_set_maxrank(arg1: 'struct FTRegress *', arg2: 'size_t') -> "void":
    return _c3.ft_regress_set_maxrank(arg1, arg2)
ft_regress_set_maxrank = _c3.ft_regress_set_maxrank

def ft_regress_set_kickrank(arg1: 'struct FTRegress *', arg2: 'size_t') -> "void":
    return _c3.ft_regress_set_kickrank(arg1, arg2)
ft_regress_set_kickrank = _c3.ft_regress_set_kickrank

def ft_regress_set_roundtol(arg1: 'struct FTRegress *', arg2: 'double') -> "void":
    return _c3.ft_regress_set_roundtol(arg1, arg2)
ft_regress_set_roundtol = _c3.ft_regress_set_roundtol

def ft_regress_set_kfold(arg1: 'struct FTRegress *', arg2: 'size_t') -> "void":
    return _c3.ft_regress_set_kfold(arg1, arg2)
ft_regress_set_kfold = _c3.ft_regress_set_kfold

def ft_regress_set_finalize(arg1: 'struct FTRegress *', arg2: 'int') -> "void":
    return _c3.ft_regress_set_finalize(arg1, arg2)
ft_regress_set_finalize = _c3.ft_regress_set_finalize

def ft_regress_set_opt_restrict(arg1: 'struct FTRegress *', arg2: 'int') -> "void":
    return _c3.ft_regress_set_opt_restrict(arg1, arg2)
ft_regress_set_opt_restrict = _c3.ft_regress_set_opt_restrict

def ft_regress_set_kristoffel(arg1: 'struct FTRegress *', arg2: 'int') -> "void":
    return _c3.ft_regress_set_kristoffel(arg1, arg2)
ft_regress_set_kristoffel = _c3.ft_regress_set_kristoffel

def ft_regress_free(arg1: 'struct FTRegress *') -> "void":
    return _c3.ft_regress_free(arg1)
ft_regress_free = _c3.ft_regress_free

def ft_regress_reset_param(arg1: 'struct FTRegress *', arg2: 'struct MultiApproxOpts *', arg3: 'size_t *') -> "void":
    return _c3.ft_regress_reset_param(arg1, arg2, arg3)
ft_regress_reset_param = _c3.ft_regress_reset_param

def ft_regress_set_type(arg1: 'struct FTRegress *', arg2: 'enum REGTYPE') -> "void":
    return _c3.ft_regress_set_type(arg1, arg2)
ft_regress_set_type = _c3.ft_regress_set_type

def ft_regress_set_obj(arg1: 'struct FTRegress *', arg2: 'enum REGOBJ') -> "void":
    return _c3.ft_regress_set_obj(arg1, arg2)
ft_regress_set_obj = _c3.ft_regress_set_obj

def ft_regress_set_alg_and_obj(arg1: 'struct FTRegress *', arg2: 'enum REGTYPE', arg3: 'enum REGOBJ') -> "void":
    return _c3.ft_regress_set_alg_and_obj(arg1, arg2, arg3)
ft_regress_set_alg_and_obj = _c3.ft_regress_set_alg_and_obj

def ft_regress_set_als_conv_tol(arg1: 'struct FTRegress *', arg2: 'double') -> "void":
    return _c3.ft_regress_set_als_conv_tol(arg1, arg2)
ft_regress_set_als_conv_tol = _c3.ft_regress_set_als_conv_tol

def ft_regress_set_max_als_sweep(arg1: 'struct FTRegress *', arg2: 'size_t') -> "void":
    return _c3.ft_regress_set_max_als_sweep(arg1, arg2)
ft_regress_set_max_als_sweep = _c3.ft_regress_set_max_als_sweep

def ft_regress_set_verbose(arg1: 'struct FTRegress *', arg2: 'int') -> "void":
    return _c3.ft_regress_set_verbose(arg1, arg2)
ft_regress_set_verbose = _c3.ft_regress_set_verbose

def ft_regress_set_regularization_weight(arg1: 'struct FTRegress *', arg2: 'double') -> "void":
    return _c3.ft_regress_set_regularization_weight(arg1, arg2)
ft_regress_set_regularization_weight = _c3.ft_regress_set_regularization_weight

def ft_regress_get_regularization_weight(arg1: 'struct FTRegress const *') -> "double":
    return _c3.ft_regress_get_regularization_weight(arg1)
ft_regress_get_regularization_weight = _c3.ft_regress_get_regularization_weight

def ft_regress_get_nepochs(arg1: 'struct FTRegress const *') -> "size_t":
    return _c3.ft_regress_get_nepochs(arg1)
ft_regress_get_nepochs = _c3.ft_regress_get_nepochs

def ft_regress_get_stored_fvals(arg1: 'struct FTRegress const *', arg2: 'size_t') -> "double":
    return _c3.ft_regress_get_stored_fvals(arg1, arg2)
ft_regress_get_stored_fvals = _c3.ft_regress_get_stored_fvals

def ft_regress_get_params(arg1: 'struct FTRegress *', arg2: 'size_t *') -> "double *":
    return _c3.ft_regress_get_params(arg1, arg2)
ft_regress_get_params = _c3.ft_regress_get_params

def ft_regress_update_params(arg1: 'struct FTRegress *', arg2: 'double const *') -> "void":
    return _c3.ft_regress_update_params(arg1, arg2)
ft_regress_update_params = _c3.ft_regress_update_params

def ft_regress_run_rankadapt(arg1: 'struct FTRegress *', arg2: 'double', arg3: 'size_t', arg4: 'size_t', arg5: 'struct c3Opt *', arg6: 'int', arg7: 'size_t', arg8: 'double const *', arg9: 'double const *', arg10: 'int') -> "struct FunctionTrain *":
    return _c3.ft_regress_run_rankadapt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
ft_regress_run_rankadapt = _c3.ft_regress_run_rankadapt

def cross_validate_free(arg1: 'struct CrossValidate *') -> "void":
    return _c3.cross_validate_free(arg1)
cross_validate_free = _c3.cross_validate_free

def cross_validate_run(arg1: 'struct CrossValidate *', arg2: 'struct FTRegress *', arg3: 'struct c3Opt *') -> "double":
    return _c3.cross_validate_run(arg1, arg2, arg3)
cross_validate_run = _c3.cross_validate_run

def cv_opt_grid_init(arg1: 'size_t') -> "struct CVOptGrid *":
    return _c3.cv_opt_grid_init(arg1)
cv_opt_grid_init = _c3.cv_opt_grid_init

def cv_opt_grid_free(arg1: 'struct CVOptGrid *') -> "void":
    return _c3.cv_opt_grid_free(arg1)
cv_opt_grid_free = _c3.cv_opt_grid_free

def cv_opt_grid_set_verbose(arg1: 'struct CVOptGrid *', arg2: 'int') -> "void":
    return _c3.cv_opt_grid_set_verbose(arg1, arg2)
cv_opt_grid_set_verbose = _c3.cv_opt_grid_set_verbose

def cv_opt_grid_add_param(arg1: 'struct CVOptGrid *', arg2: 'char *', arg3: 'size_t', paramlist: 'void *') -> "void":
    return _c3.cv_opt_grid_add_param(arg1, arg2, arg3, paramlist)
cv_opt_grid_add_param = _c3.cv_opt_grid_add_param

def cross_validate_grid_opt(arg1: 'struct CrossValidate *', arg2: 'struct CVOptGrid *', arg3: 'struct FTRegress *', arg4: 'struct c3Opt *') -> "void":
    return _c3.cross_validate_grid_opt(arg1, arg2, arg3, arg4)
cross_validate_grid_opt = _c3.cross_validate_grid_opt

def c3_regression_run(arg1: 'FTparam', arg2: 'RegressOpts', arg3: 'struct c3Opt *', N: 'size_t', x: 'double const *', y: 'double const *') -> "struct FunctionTrain *":
    return _c3.c3_regression_run(arg1, arg2, arg3, N, x, y)
c3_regression_run = _c3.c3_regression_run
ALS = _c3.ALS
AIO = _c3.AIO
REGNONE = _c3.REGNONE
FTLS = _c3.FTLS
FTLS_SPARSEL2 = _c3.FTLS_SPARSEL2
REGOBJNONE = _c3.REGOBJNONE
class RegressOpts(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RegressOpts, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RegressOpts, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _c3.RegressOpts_type_set
    __swig_getmethods__["type"] = _c3.RegressOpts_type_get
    if _newclass:
        type = _swig_property(_c3.RegressOpts_type_get, _c3.RegressOpts_type_set)
    __swig_setmethods__["obj"] = _c3.RegressOpts_obj_set
    __swig_getmethods__["obj"] = _c3.RegressOpts_obj_get
    if _newclass:
        obj = _swig_property(_c3.RegressOpts_obj_get, _c3.RegressOpts_obj_set)
    __swig_setmethods__["dim"] = _c3.RegressOpts_dim_set
    __swig_getmethods__["dim"] = _c3.RegressOpts_dim_get
    if _newclass:
        dim = _swig_property(_c3.RegressOpts_dim_get, _c3.RegressOpts_dim_set)
    __swig_setmethods__["verbose"] = _c3.RegressOpts_verbose_set
    __swig_getmethods__["verbose"] = _c3.RegressOpts_verbose_get
    if _newclass:
        verbose = _swig_property(_c3.RegressOpts_verbose_get, _c3.RegressOpts_verbose_set)
    __swig_setmethods__["regularization_weight"] = _c3.RegressOpts_regularization_weight_set
    __swig_getmethods__["regularization_weight"] = _c3.RegressOpts_regularization_weight_get
    if _newclass:
        regularization_weight = _swig_property(_c3.RegressOpts_regularization_weight_get, _c3.RegressOpts_regularization_weight_set)
    __swig_setmethods__["max_als_sweeps"] = _c3.RegressOpts_max_als_sweeps_set
    __swig_getmethods__["max_als_sweeps"] = _c3.RegressOpts_max_als_sweeps_get
    if _newclass:
        max_als_sweeps = _swig_property(_c3.RegressOpts_max_als_sweeps_get, _c3.RegressOpts_max_als_sweeps_set)
    __swig_setmethods__["als_active_core"] = _c3.RegressOpts_als_active_core_set
    __swig_getmethods__["als_active_core"] = _c3.RegressOpts_als_active_core_get
    if _newclass:
        als_active_core = _swig_property(_c3.RegressOpts_als_active_core_get, _c3.RegressOpts_als_active_core_set)
    __swig_setmethods__["als_conv_tol"] = _c3.RegressOpts_als_conv_tol_set
    __swig_getmethods__["als_conv_tol"] = _c3.RegressOpts_als_conv_tol_get
    if _newclass:
        als_conv_tol = _swig_property(_c3.RegressOpts_als_conv_tol_get, _c3.RegressOpts_als_conv_tol_set)
    __swig_setmethods__["restrict_rank_opt"] = _c3.RegressOpts_restrict_rank_opt_set
    __swig_getmethods__["restrict_rank_opt"] = _c3.RegressOpts_restrict_rank_opt_get
    if _newclass:
        restrict_rank_opt = _swig_property(_c3.RegressOpts_restrict_rank_opt_get, _c3.RegressOpts_restrict_rank_opt_set)
    __swig_setmethods__["kristoffel_active"] = _c3.RegressOpts_kristoffel_active_set
    __swig_getmethods__["kristoffel_active"] = _c3.RegressOpts_kristoffel_active_get
    if _newclass:
        kristoffel_active = _swig_property(_c3.RegressOpts_kristoffel_active_get, _c3.RegressOpts_kristoffel_active_set)
    __swig_setmethods__["nepochs"] = _c3.RegressOpts_nepochs_set
    __swig_getmethods__["nepochs"] = _c3.RegressOpts_nepochs_get
    if _newclass:
        nepochs = _swig_property(_c3.RegressOpts_nepochs_get, _c3.RegressOpts_nepochs_set)
    __swig_setmethods__["stored_fvals"] = _c3.RegressOpts_stored_fvals_set
    __swig_getmethods__["stored_fvals"] = _c3.RegressOpts_stored_fvals_get
    if _newclass:
        stored_fvals = _swig_property(_c3.RegressOpts_stored_fvals_get, _c3.RegressOpts_stored_fvals_set)
    __swig_setmethods__["sample_weights"] = _c3.RegressOpts_sample_weights_set
    __swig_getmethods__["sample_weights"] = _c3.RegressOpts_sample_weights_get
    if _newclass:
        sample_weights = _swig_property(_c3.RegressOpts_sample_weights_get, _c3.RegressOpts_sample_weights_set)

    def __init__(self):
        this = _c3.new_RegressOpts()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_RegressOpts
    __del__ = lambda self: None
RegressOpts_swigregister = _c3.RegressOpts_swigregister
RegressOpts_swigregister(RegressOpts)


def regress_opts_alloc(arg1: 'size_t') -> "struct RegressOpts *":
    return _c3.regress_opts_alloc(arg1)
regress_opts_alloc = _c3.regress_opts_alloc

def regress_opts_free(arg1: 'RegressOpts') -> "void":
    return _c3.regress_opts_free(arg1)
regress_opts_free = _c3.regress_opts_free

def regress_opts_create(arg1: 'size_t', arg2: 'enum REGTYPE', arg3: 'enum REGOBJ') -> "struct RegressOpts *":
    return _c3.regress_opts_create(arg1, arg2, arg3)
regress_opts_create = _c3.regress_opts_create

def regress_opts_set_sample_weights(arg1: 'RegressOpts', arg2: 'double const *') -> "void":
    return _c3.regress_opts_set_sample_weights(arg1, arg2)
regress_opts_set_sample_weights = _c3.regress_opts_set_sample_weights

def regress_opts_set_max_als_sweep(arg1: 'RegressOpts', arg2: 'size_t') -> "void":
    return _c3.regress_opts_set_max_als_sweep(arg1, arg2)
regress_opts_set_max_als_sweep = _c3.regress_opts_set_max_als_sweep

def regress_opts_set_kristoffel(arg1: 'RegressOpts', arg2: 'int') -> "void":
    return _c3.regress_opts_set_kristoffel(arg1, arg2)
regress_opts_set_kristoffel = _c3.regress_opts_set_kristoffel

def regress_opts_set_als_conv_tol(arg1: 'RegressOpts', arg2: 'double') -> "void":
    return _c3.regress_opts_set_als_conv_tol(arg1, arg2)
regress_opts_set_als_conv_tol = _c3.regress_opts_set_als_conv_tol

def regress_opts_set_verbose(arg1: 'RegressOpts', arg2: 'int') -> "void":
    return _c3.regress_opts_set_verbose(arg1, arg2)
regress_opts_set_verbose = _c3.regress_opts_set_verbose

def regress_opts_set_restrict_rank(arg1: 'RegressOpts', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.regress_opts_set_restrict_rank(arg1, arg2, arg3)
regress_opts_set_restrict_rank = _c3.regress_opts_set_restrict_rank

def regress_opts_set_regularization_weight(arg1: 'RegressOpts', arg2: 'double') -> "void":
    return _c3.regress_opts_set_regularization_weight(arg1, arg2)
regress_opts_set_regularization_weight = _c3.regress_opts_set_regularization_weight

def regress_opts_get_regularization_weight(arg1: 'RegressOpts') -> "double":
    return _c3.regress_opts_get_regularization_weight(arg1)
regress_opts_get_regularization_weight = _c3.regress_opts_get_regularization_weight

def regress_opts_add_stored_vals(arg1: 'RegressOpts', arg2: 'size_t', arg3: 'double *') -> "void":
    return _c3.regress_opts_add_stored_vals(arg1, arg2, arg3)
regress_opts_add_stored_vals = _c3.regress_opts_add_stored_vals

def regress_opts_get_nepochs(arg1: 'RegressOpts') -> "size_t":
    return _c3.regress_opts_get_nepochs(arg1)
regress_opts_get_nepochs = _c3.regress_opts_get_nepochs

def regress_opts_get_stored_fvals(arg1: 'RegressOpts') -> "double *":
    return _c3.regress_opts_get_stored_fvals(arg1)
regress_opts_get_stored_fvals = _c3.regress_opts_get_stored_fvals

def objective_function_add(obj: 'struct ObjectiveFunction **', weight: 'double', func: 'double (*)(size_t,double const *,double *,size_t,size_t *,struct Data *,struct SLMemManager *,void *)', arg: 'void *') -> "void":
    return _c3.objective_function_add(obj, weight, func, arg)
objective_function_add = _c3.objective_function_add

def objective_function_free(obj: 'struct ObjectiveFunction **') -> "void":
    return _c3.objective_function_free(obj)
objective_function_free = _c3.objective_function_free

def objective_eval(arg1: 'size_t', arg2: 'double const *', arg3: 'double *', arg4: 'size_t', arg5: 'size_t *', arg6: 'void *') -> "double":
    return _c3.objective_eval(arg1, arg2, arg3, arg4, arg5, arg6)
objective_eval = _c3.objective_eval
class LeastSquaresArgs(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LeastSquaresArgs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LeastSquaresArgs, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mapping"] = _c3.LeastSquaresArgs_mapping_set
    __swig_getmethods__["mapping"] = _c3.LeastSquaresArgs_mapping_get
    if _newclass:
        mapping = _swig_property(_c3.LeastSquaresArgs_mapping_get, _c3.LeastSquaresArgs_mapping_set)
    __swig_setmethods__["args"] = _c3.LeastSquaresArgs_args_set
    __swig_getmethods__["args"] = _c3.LeastSquaresArgs_args_get
    if _newclass:
        args = _swig_property(_c3.LeastSquaresArgs_args_get, _c3.LeastSquaresArgs_args_set)

    def __init__(self):
        this = _c3.new_LeastSquaresArgs()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_LeastSquaresArgs
    __del__ = lambda self: None
LeastSquaresArgs_swigregister = _c3.LeastSquaresArgs_swigregister
LeastSquaresArgs_swigregister(LeastSquaresArgs)


def c3_objective_function_least_squares(nparam: 'size_t', param: 'double const *', grad: 'double *', Ndata: 'size_t', data_index: 'size_t *', data: 'struct Data *', mem: 'struct SLMemManager *', args: 'void *') -> "double":
    return _c3.c3_objective_function_least_squares(nparam, param, grad, Ndata, data_index, data, mem, args)
c3_objective_function_least_squares = _c3.c3_objective_function_least_squares
LINEAR_ST = _c3.LINEAR_ST
NONE_ST = _c3.NONE_ST
class FTparam(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FTparam, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FTparam, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ft"] = _c3.FTparam_ft_set
    __swig_getmethods__["ft"] = _c3.FTparam_ft_get
    if _newclass:
        ft = _swig_property(_c3.FTparam_ft_get, _c3.FTparam_ft_set)
    __swig_setmethods__["dim"] = _c3.FTparam_dim_set
    __swig_getmethods__["dim"] = _c3.FTparam_dim_get
    if _newclass:
        dim = _swig_property(_c3.FTparam_dim_get, _c3.FTparam_dim_set)
    __swig_setmethods__["nparams_per_uni"] = _c3.FTparam_nparams_per_uni_set
    __swig_getmethods__["nparams_per_uni"] = _c3.FTparam_nparams_per_uni_get
    if _newclass:
        nparams_per_uni = _swig_property(_c3.FTparam_nparams_per_uni_get, _c3.FTparam_nparams_per_uni_set)
    __swig_setmethods__["nparams_per_core"] = _c3.FTparam_nparams_per_core_set
    __swig_getmethods__["nparams_per_core"] = _c3.FTparam_nparams_per_core_get
    if _newclass:
        nparams_per_core = _swig_property(_c3.FTparam_nparams_per_core_get, _c3.FTparam_nparams_per_core_set)
    __swig_setmethods__["max_param_uni"] = _c3.FTparam_max_param_uni_set
    __swig_getmethods__["max_param_uni"] = _c3.FTparam_max_param_uni_get
    if _newclass:
        max_param_uni = _swig_property(_c3.FTparam_max_param_uni_get, _c3.FTparam_max_param_uni_set)
    __swig_setmethods__["nparams"] = _c3.FTparam_nparams_set
    __swig_getmethods__["nparams"] = _c3.FTparam_nparams_get
    if _newclass:
        nparams = _swig_property(_c3.FTparam_nparams_get, _c3.FTparam_nparams_set)
    __swig_setmethods__["params"] = _c3.FTparam_params_set
    __swig_getmethods__["params"] = _c3.FTparam_params_get
    if _newclass:
        params = _swig_property(_c3.FTparam_params_get, _c3.FTparam_params_set)
    __swig_setmethods__["approx_opts"] = _c3.FTparam_approx_opts_set
    __swig_getmethods__["approx_opts"] = _c3.FTparam_approx_opts_get
    if _newclass:
        approx_opts = _swig_property(_c3.FTparam_approx_opts_get, _c3.FTparam_approx_opts_set)

    def __init__(self):
        this = _c3.new_FTparam()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_FTparam
    __del__ = lambda self: None
FTparam_swigregister = _c3.FTparam_swigregister
FTparam_swigregister(FTparam)


def ft_param_alloc(arg1: 'size_t', arg2: 'struct MultiApproxOpts *', arg3: 'double *', arg4: 'size_t *') -> "struct FTparam *":
    return _c3.ft_param_alloc(arg1, arg2, arg3, arg4)
ft_param_alloc = _c3.ft_param_alloc

def ft_param_free(arg1: 'FTparam') -> "void":
    return _c3.ft_param_free(arg1)
ft_param_free = _c3.ft_param_free

def ft_param_get_param(arg1: 'FTparam', arg2: 'size_t') -> "double":
    return _c3.ft_param_get_param(arg1, arg2)
ft_param_get_param = _c3.ft_param_get_param

def ft_param_get_nparams(arg1: 'FTparam') -> "size_t":
    return _c3.ft_param_get_nparams(arg1)
ft_param_get_nparams = _c3.ft_param_get_nparams

def ft_param_get_nparams_restrict(arg1: 'FTparam', arg2: 'size_t const *') -> "size_t":
    return _c3.ft_param_get_nparams_restrict(arg1, arg2)
ft_param_get_nparams_restrict = _c3.ft_param_get_nparams_restrict

def ft_param_get_nparams_per_core(arg1: 'FTparam') -> "size_t *":
    return _c3.ft_param_get_nparams_per_core(arg1)
ft_param_get_nparams_per_core = _c3.ft_param_get_nparams_per_core

def ft_param_get_ft(arg1: 'FTparam') -> "struct FunctionTrain *":
    return _c3.ft_param_get_ft(arg1)
ft_param_get_ft = _c3.ft_param_get_ft

def ft_param_create_constant(arg1: 'FTparam', arg2: 'double', arg3: 'double') -> "void":
    return _c3.ft_param_create_constant(arg1, arg2, arg3)
ft_param_create_constant = _c3.ft_param_create_constant

def ft_param_create_from_lin_ls(arg1: 'FTparam', arg2: 'size_t', arg3: 'double const *', arg4: 'double const *', arg5: 'double') -> "void":
    return _c3.ft_param_create_from_lin_ls(arg1, arg2, arg3, arg4, arg5)
ft_param_create_from_lin_ls = _c3.ft_param_create_from_lin_ls

def ft_param_update_params(arg1: 'FTparam', arg2: 'double const *') -> "void":
    return _c3.ft_param_update_params(arg1, arg2)
ft_param_update_params = _c3.ft_param_update_params

def ft_param_update_restricted_ranks(arg1: 'FTparam', arg2: 'double const *', arg3: 'size_t const *') -> "void":
    return _c3.ft_param_update_restricted_ranks(arg1, arg2, arg3)
ft_param_update_restricted_ranks = _c3.ft_param_update_restricted_ranks

def ft_param_update_inside_restricted_ranks(arg1: 'FTparam', arg2: 'double const *', arg3: 'size_t const *') -> "void":
    return _c3.ft_param_update_inside_restricted_ranks(arg1, arg2, arg3)
ft_param_update_inside_restricted_ranks = _c3.ft_param_update_inside_restricted_ranks

def ft_param_update_core_params(arg1: 'FTparam', arg2: 'size_t', arg3: 'double const *') -> "void":
    return _c3.ft_param_update_core_params(arg1, arg2, arg3)
ft_param_update_core_params = _c3.ft_param_update_core_params

def ft_param_extract_structure(arg1: 'FTparam') -> "enum FTPARAM_ST":
    return _c3.ft_param_extract_structure(arg1)
ft_param_extract_structure = _c3.ft_param_extract_structure

def ft_param_gradeval(arg1: 'FTparam', arg2: 'double const *', arg3: 'double *', arg4: 'double *', arg5: 'double *', arg6: 'double *') -> "double":
    return _c3.ft_param_gradeval(arg1, arg2, arg3, arg4, arg5, arg6)
ft_param_gradeval = _c3.ft_param_gradeval

def ft_param_eval_lin(arg1: 'FTparam', arg2: 'double const *', arg3: 'double *') -> "double":
    return _c3.ft_param_eval_lin(arg1, arg2, arg3)
ft_param_eval_lin = _c3.ft_param_eval_lin

def ft_param_gradeval_lin(arg1: 'FTparam', arg2: 'double const *', arg3: 'double *', arg4: 'double *', arg5: 'double *') -> "double":
    return _c3.ft_param_gradeval_lin(arg1, arg2, arg3, arg4, arg5)
ft_param_gradeval_lin = _c3.ft_param_gradeval_lin

def process_sweep_left_right(ftp: 'FTparam', current_core: 'size_t', x: 'double', evals: 'double *', running_lr: 'double *', running_lr_up: 'double *') -> "void":
    return _c3.process_sweep_left_right(ftp, current_core, x, evals, running_lr, running_lr_up)
process_sweep_left_right = _c3.process_sweep_left_right

def process_sweep_right_left(ftp: 'FTparam', current_core: 'size_t', x: 'double', evals: 'double *', running_rl: 'double *', running_rl_up: 'double *') -> "void":
    return _c3.process_sweep_right_left(ftp, current_core, x, evals, running_rl, running_rl_up)
process_sweep_right_left = _c3.process_sweep_right_left

def process_sweep_left_right_lin(ftp: 'FTparam', current_core: 'size_t', evals: 'double *', running_lr: 'double *', running_lr_up: 'double *') -> "void":
    return _c3.process_sweep_left_right_lin(ftp, current_core, evals, running_lr, running_lr_up)
process_sweep_left_right_lin = _c3.process_sweep_left_right_lin

def process_sweep_right_left_lin(ftp: 'FTparam', current_core: 'size_t', evals: 'double *', running_rl: 'double *', running_rl_up: 'double *') -> "void":
    return _c3.process_sweep_right_left_lin(ftp, current_core, evals, running_rl, running_rl_up)
process_sweep_right_left_lin = _c3.process_sweep_right_left_lin

def ft_param_core_gradeval(ftp: 'FTparam', core: 'size_t', x: 'double', arg4: 'double *', arg5: 'double *', running_rl: 'double *', arg7: 'double *') -> "double":
    return _c3.ft_param_core_gradeval(ftp, core, x, arg4, arg5, running_rl, arg7)
ft_param_core_gradeval = _c3.ft_param_core_gradeval

def ft_param_core_eval_lin(arg1: 'FTparam', arg2: 'size_t', arg3: 'double *', arg4: 'double *', arg5: 'double const *') -> "double":
    return _c3.ft_param_core_eval_lin(arg1, arg2, arg3, arg4, arg5)
ft_param_core_eval_lin = _c3.ft_param_core_eval_lin

def ft_param_core_gradeval_lin(ftp: 'FTparam', core: 'size_t', grad: 'double *', running_lr: 'double *', running_rl: 'double *', grad_evals: 'double *') -> "double":
    return _c3.ft_param_core_gradeval_lin(ftp, core, grad, running_lr, running_rl, grad_evals)
ft_param_core_gradeval_lin = _c3.ft_param_core_gradeval_lin

def ft_param_hessvec(ftp: 'FTparam', x: 'double const *', vec: 'double const *', hess_vec: 'double *') -> "double":
    return _c3.ft_param_hessvec(ftp, x, vec, hess_vec)
ft_param_hessvec = _c3.ft_param_hessvec
class SLP(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SLP, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SLP, name)
    __repr__ = _swig_repr
    __swig_setmethods__["objective_function"] = _c3.SLP_objective_function_set
    __swig_getmethods__["objective_function"] = _c3.SLP_objective_function_get
    if _newclass:
        objective_function = _swig_property(_c3.SLP_objective_function_get, _c3.SLP_objective_function_set)
    __swig_setmethods__["optimizer"] = _c3.SLP_optimizer_set
    __swig_getmethods__["optimizer"] = _c3.SLP_optimizer_get
    if _newclass:
        optimizer = _swig_property(_c3.SLP_optimizer_get, _c3.SLP_optimizer_set)
    __swig_setmethods__["data"] = _c3.SLP_data_set
    __swig_getmethods__["data"] = _c3.SLP_data_get
    if _newclass:
        data = _swig_property(_c3.SLP_data_get, _c3.SLP_data_set)
    __swig_setmethods__["mem"] = _c3.SLP_mem_set
    __swig_getmethods__["mem"] = _c3.SLP_mem_get
    if _newclass:
        mem = _swig_property(_c3.SLP_mem_get, _c3.SLP_mem_set)
    __swig_setmethods__["nparams"] = _c3.SLP_nparams_set
    __swig_getmethods__["nparams"] = _c3.SLP_nparams_get
    if _newclass:
        nparams = _swig_property(_c3.SLP_nparams_get, _c3.SLP_nparams_set)
    __swig_setmethods__["obj_min"] = _c3.SLP_obj_min_set
    __swig_getmethods__["obj_min"] = _c3.SLP_obj_min_get
    if _newclass:
        obj_min = _swig_property(_c3.SLP_obj_min_get, _c3.SLP_obj_min_set)

    def __init__(self):
        this = _c3.new_SLP()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_SLP
    __del__ = lambda self: None
SLP_swigregister = _c3.SLP_swigregister
SLP_swigregister(SLP)


def slp_solve(arg1: 'SLP', arg2: 'double *') -> "int":
    return _c3.slp_solve(arg1, arg2)
slp_solve = _c3.slp_solve

def slp_get_minimum(slp: 'SLP') -> "double":
    return _c3.slp_get_minimum(slp)
slp_get_minimum = _c3.slp_get_minimum

def dmrg_diffusion_midleft(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'Qmarray', arg5: 'Qmarray', arg6: 'double *', arg7: 'size_t', arg8: 'Qmarray') -> "void":
    return _c3.dmrg_diffusion_midleft(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_diffusion_midleft = _c3.dmrg_diffusion_midleft

def dmrg_diffusion_lastleft(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'Qmarray', arg5: 'Qmarray', arg6: 'double *', arg7: 'size_t', arg8: 'Qmarray') -> "void":
    return _c3.dmrg_diffusion_lastleft(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_diffusion_lastleft = _c3.dmrg_diffusion_lastleft

def dmrg_diffusion_midright(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'Qmarray', arg5: 'Qmarray', arg6: 'double *', arg7: 'size_t', arg8: 'Qmarray') -> "void":
    return _c3.dmrg_diffusion_midright(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_diffusion_midright = _c3.dmrg_diffusion_midright

def dmrg_diffusion_firstright(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'Qmarray', arg5: 'Qmarray', arg6: 'double *', arg7: 'size_t', arg8: 'Qmarray') -> "void":
    return _c3.dmrg_diffusion_firstright(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_diffusion_firstright = _c3.dmrg_diffusion_firstright
class DmDiff(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DmDiff, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DmDiff, name)
    __repr__ = _swig_repr
    __swig_setmethods__["A"] = _c3.DmDiff_A_set
    __swig_getmethods__["A"] = _c3.DmDiff_A_get
    if _newclass:
        A = _swig_property(_c3.DmDiff_A_get, _c3.DmDiff_A_set)
    __swig_setmethods__["F"] = _c3.DmDiff_F_set
    __swig_getmethods__["F"] = _c3.DmDiff_F_get
    if _newclass:
        F = _swig_property(_c3.DmDiff_F_get, _c3.DmDiff_F_set)
    __swig_setmethods__["dA"] = _c3.DmDiff_dA_set
    __swig_getmethods__["dA"] = _c3.DmDiff_dA_get
    if _newclass:
        dA = _swig_property(_c3.DmDiff_dA_get, _c3.DmDiff_dA_set)
    __swig_setmethods__["dF"] = _c3.DmDiff_dF_set
    __swig_getmethods__["dF"] = _c3.DmDiff_dF_get
    if _newclass:
        dF = _swig_property(_c3.DmDiff_dF_get, _c3.DmDiff_dF_set)
    __swig_setmethods__["ddF"] = _c3.DmDiff_ddF_set
    __swig_getmethods__["ddF"] = _c3.DmDiff_ddF_get
    if _newclass:
        ddF = _swig_property(_c3.DmDiff_ddF_get, _c3.DmDiff_ddF_set)

    def __init__(self):
        this = _c3.new_DmDiff()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_DmDiff
    __del__ = lambda self: None
DmDiff_swigregister = _c3.DmDiff_swigregister
DmDiff_swigregister(DmDiff)


def dmrg_diffusion(arg1: 'FunctionTrain', arg2: 'FunctionTrain', arg3: 'double', arg4: 'size_t', arg5: 'double', arg6: 'int', arg7: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.dmrg_diffusion(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
dmrg_diffusion = _c3.dmrg_diffusion

def exact_diffusion(arg1: 'FunctionTrain', arg2: 'FunctionTrain', arg3: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.exact_diffusion(arg1, arg2, arg3)
exact_diffusion = _c3.exact_diffusion

def exact_laplace(arg1: 'FunctionTrain', arg2: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.exact_laplace(arg1, arg2)
exact_laplace = _c3.exact_laplace

def exact_laplace_periodic(arg1: 'FunctionTrain', arg2: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.exact_laplace_periodic(arg1, arg2)
exact_laplace_periodic = _c3.exact_laplace_periodic

def exact_laplace_op(arg1: 'FunctionTrain', arg2: 'struct Operator **', arg3: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.exact_laplace_op(arg1, arg2, arg3)
exact_laplace_op = _c3.exact_laplace_op
class QR(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QR, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QR, name)
    __repr__ = _swig_repr
    __swig_setmethods__["right"] = _c3.QR_right_set
    __swig_getmethods__["right"] = _c3.QR_right_get
    if _newclass:
        right = _swig_property(_c3.QR_right_get, _c3.QR_right_set)
    __swig_setmethods__["mat"] = _c3.QR_mat_set
    __swig_getmethods__["mat"] = _c3.QR_mat_get
    if _newclass:
        mat = _swig_property(_c3.QR_mat_get, _c3.QR_mat_set)
    __swig_setmethods__["mr"] = _c3.QR_mr_set
    __swig_getmethods__["mr"] = _c3.QR_mr_get
    if _newclass:
        mr = _swig_property(_c3.QR_mr_get, _c3.QR_mr_set)
    __swig_setmethods__["mc"] = _c3.QR_mc_set
    __swig_getmethods__["mc"] = _c3.QR_mc_get
    if _newclass:
        mc = _swig_property(_c3.QR_mc_get, _c3.QR_mc_set)
    __swig_setmethods__["Q"] = _c3.QR_Q_set
    __swig_getmethods__["Q"] = _c3.QR_Q_get
    if _newclass:
        Q = _swig_property(_c3.QR_Q_get, _c3.QR_Q_set)

    def __init__(self):
        this = _c3.new_QR()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_QR
    __del__ = lambda self: None
QR_swigregister = _c3.QR_swigregister
QR_swigregister(QR)


def qr_reduced(arg1: 'Qmarray', arg2: 'int', arg3: 'OneApproxOpts') -> "struct QR *":
    return _c3.qr_reduced(arg1, arg2, arg3)
qr_reduced = _c3.qr_reduced

def qr_free(arg1: 'QR') -> "void":
    return _c3.qr_free(arg1)
qr_free = _c3.qr_free

def qr_array_free(arg1: 'struct QR **', arg2: 'size_t') -> "void":
    return _c3.qr_array_free(arg1, arg2)
qr_array_free = _c3.qr_array_free

def qr_array_alloc(arg1: 'size_t') -> "struct QR **":
    return _c3.qr_array_alloc(arg1)
qr_array_alloc = _c3.qr_array_alloc

def dmrg_approx(arg1: 'FunctionTrain', arg2: 'void (*)(char,size_t,size_t,double *,struct Qmarray **,void *)', arg3: 'void *', arg4: 'double', arg5: 'size_t', arg6: 'double', arg7: 'int', arg8: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.dmrg_approx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_approx = _c3.dmrg_approx
class DmProd(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DmProd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DmProd, name)
    __repr__ = _swig_repr
    __swig_setmethods__["a"] = _c3.DmProd_a_set
    __swig_getmethods__["a"] = _c3.DmProd_a_get
    if _newclass:
        a = _swig_property(_c3.DmProd_a_get, _c3.DmProd_a_set)
    __swig_setmethods__["b"] = _c3.DmProd_b_set
    __swig_getmethods__["b"] = _c3.DmProd_b_get
    if _newclass:
        b = _swig_property(_c3.DmProd_b_get, _c3.DmProd_b_set)

    def __init__(self):
        this = _c3.new_DmProd()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_DmProd
    __del__ = lambda self: None
DmProd_swigregister = _c3.DmProd_swigregister
DmProd_swigregister(DmProd)


def dmrg_product(arg1: 'FunctionTrain', arg2: 'FunctionTrain', arg3: 'FunctionTrain', arg4: 'double', arg5: 'size_t', arg6: 'double', arg7: 'int', arg8: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.dmrg_product(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
dmrg_product = _c3.dmrg_product
class FunctionTrain(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FunctionTrain, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FunctionTrain, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dim"] = _c3.FunctionTrain_dim_set
    __swig_getmethods__["dim"] = _c3.FunctionTrain_dim_get
    if _newclass:
        dim = _swig_property(_c3.FunctionTrain_dim_get, _c3.FunctionTrain_dim_set)
    __swig_setmethods__["ranks"] = _c3.FunctionTrain_ranks_set
    __swig_getmethods__["ranks"] = _c3.FunctionTrain_ranks_get
    if _newclass:
        ranks = _swig_property(_c3.FunctionTrain_ranks_get, _c3.FunctionTrain_ranks_set)
    __swig_setmethods__["cores"] = _c3.FunctionTrain_cores_set
    __swig_getmethods__["cores"] = _c3.FunctionTrain_cores_get
    if _newclass:
        cores = _swig_property(_c3.FunctionTrain_cores_get, _c3.FunctionTrain_cores_set)
    __swig_setmethods__["evalspace1"] = _c3.FunctionTrain_evalspace1_set
    __swig_getmethods__["evalspace1"] = _c3.FunctionTrain_evalspace1_get
    if _newclass:
        evalspace1 = _swig_property(_c3.FunctionTrain_evalspace1_get, _c3.FunctionTrain_evalspace1_set)
    __swig_setmethods__["evalspace2"] = _c3.FunctionTrain_evalspace2_set
    __swig_getmethods__["evalspace2"] = _c3.FunctionTrain_evalspace2_get
    if _newclass:
        evalspace2 = _swig_property(_c3.FunctionTrain_evalspace2_get, _c3.FunctionTrain_evalspace2_set)
    __swig_setmethods__["evalspace3"] = _c3.FunctionTrain_evalspace3_set
    __swig_getmethods__["evalspace3"] = _c3.FunctionTrain_evalspace3_get
    if _newclass:
        evalspace3 = _swig_property(_c3.FunctionTrain_evalspace3_get, _c3.FunctionTrain_evalspace3_set)
    __swig_setmethods__["evalspace4"] = _c3.FunctionTrain_evalspace4_set
    __swig_getmethods__["evalspace4"] = _c3.FunctionTrain_evalspace4_get
    if _newclass:
        evalspace4 = _swig_property(_c3.FunctionTrain_evalspace4_get, _c3.FunctionTrain_evalspace4_set)
    __swig_setmethods__["evaldd1"] = _c3.FunctionTrain_evaldd1_set
    __swig_getmethods__["evaldd1"] = _c3.FunctionTrain_evaldd1_get
    if _newclass:
        evaldd1 = _swig_property(_c3.FunctionTrain_evaldd1_get, _c3.FunctionTrain_evaldd1_set)
    __swig_setmethods__["evaldd2"] = _c3.FunctionTrain_evaldd2_set
    __swig_getmethods__["evaldd2"] = _c3.FunctionTrain_evaldd2_get
    if _newclass:
        evaldd2 = _swig_property(_c3.FunctionTrain_evaldd2_get, _c3.FunctionTrain_evaldd2_set)
    __swig_setmethods__["evaldd3"] = _c3.FunctionTrain_evaldd3_set
    __swig_getmethods__["evaldd3"] = _c3.FunctionTrain_evaldd3_get
    if _newclass:
        evaldd3 = _swig_property(_c3.FunctionTrain_evaldd3_get, _c3.FunctionTrain_evaldd3_set)
    __swig_setmethods__["evaldd4"] = _c3.FunctionTrain_evaldd4_set
    __swig_getmethods__["evaldd4"] = _c3.FunctionTrain_evaldd4_get
    if _newclass:
        evaldd4 = _swig_property(_c3.FunctionTrain_evaldd4_get, _c3.FunctionTrain_evaldd4_set)

    def __init__(self):
        this = _c3.new_FunctionTrain()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_FunctionTrain
    __del__ = lambda self: None
FunctionTrain_swigregister = _c3.FunctionTrain_swigregister
FunctionTrain_swigregister(FunctionTrain)


def function_train_copy(arg1: 'FunctionTrain') -> "struct FunctionTrain *":
    return _c3.function_train_copy(arg1)
function_train_copy = _c3.function_train_copy

def function_train_serialize(arg1: 'unsigned char *', arg2: 'FunctionTrain', arg3: 'size_t *') -> "unsigned char *":
    return _c3.function_train_serialize(arg1, arg2, arg3)
function_train_serialize = _c3.function_train_serialize

def function_train_deserialize(arg1: 'unsigned char *', arg2: 'struct FunctionTrain **') -> "unsigned char *":
    return _c3.function_train_deserialize(arg1, arg2)
function_train_deserialize = _c3.function_train_deserialize

def function_train_savetxt(arg1: 'FunctionTrain', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.function_train_savetxt(arg1, arg2, arg3)
function_train_savetxt = _c3.function_train_savetxt

def function_train_loadtxt(arg1: 'FILE *') -> "struct FunctionTrain *":
    return _c3.function_train_loadtxt(arg1)
function_train_loadtxt = _c3.function_train_loadtxt

def function_train_save(arg1: 'FunctionTrain', arg2: 'char *') -> "int":
    return _c3.function_train_save(arg1, arg2)
function_train_save = _c3.function_train_save

def function_train_load(arg1: 'char *') -> "struct FunctionTrain *":
    return _c3.function_train_load(arg1)
function_train_load = _c3.function_train_load

def function_train_get_dim(arg1: 'FunctionTrain') -> "size_t":
    return _c3.function_train_get_dim(arg1)
function_train_get_dim = _c3.function_train_get_dim

def function_train_get_ranks(arg1: 'FunctionTrain') -> "size_t *":
    return _c3.function_train_get_ranks(arg1)
function_train_get_ranks = _c3.function_train_get_ranks

def function_train_get_maxrank(arg1: 'FunctionTrain') -> "size_t":
    return _c3.function_train_get_maxrank(arg1)
function_train_get_maxrank = _c3.function_train_get_maxrank

def function_train_get_avgrank(arg1: 'FunctionTrain') -> "double":
    return _c3.function_train_get_avgrank(arg1)
function_train_get_avgrank = _c3.function_train_get_avgrank

def function_train_get_core(arg1: 'FunctionTrain', arg2: 'size_t') -> "struct Qmarray *":
    return _c3.function_train_get_core(arg1, arg2)
function_train_get_core = _c3.function_train_get_core

def function_train_eval_up_to_core(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'double const *', arg4: 'double *', arg5: 'size_t *') -> "void":
    return _c3.function_train_eval_up_to_core(arg1, arg2, arg3, arg4, arg5)
function_train_eval_up_to_core = _c3.function_train_eval_up_to_core

def function_train_func_get_nparams(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t') -> "size_t":
    return _c3.function_train_func_get_nparams(arg1, arg2, arg3, arg4)
function_train_func_get_nparams = _c3.function_train_func_get_nparams

def function_train_core_get_nparams(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t *') -> "size_t":
    return _c3.function_train_core_get_nparams(arg1, arg2, arg3)
function_train_core_get_nparams = _c3.function_train_core_get_nparams

def function_train_get_nparams(arg1: 'FunctionTrain') -> "size_t":
    return _c3.function_train_get_nparams(arg1)
function_train_get_nparams = _c3.function_train_get_nparams

def function_train_core_get_params(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'double *') -> "size_t":
    return _c3.function_train_core_get_params(arg1, arg2, arg3)
function_train_core_get_params = _c3.function_train_core_get_params

def function_train_get_params(arg1: 'FunctionTrain', arg2: 'double *') -> "size_t":
    return _c3.function_train_get_params(arg1, arg2)
function_train_get_params = _c3.function_train_get_params

def function_train_get_uni(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t') -> "void *":
    return _c3.function_train_get_uni(arg1, arg2, arg3, arg4)
function_train_get_uni = _c3.function_train_get_uni

def function_train_get_gfuni(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t') -> "struct GenericFunction *":
    return _c3.function_train_get_gfuni(arg1, arg2, arg3, arg4)
function_train_get_gfuni = _c3.function_train_get_gfuni

def function_train_uni_update_params(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t', arg6: 'double const *') -> "void":
    return _c3.function_train_uni_update_params(arg1, arg2, arg3, arg4, arg5, arg6)
function_train_uni_update_params = _c3.function_train_uni_update_params

def function_train_core_update_params(arg1: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t', arg4: 'double const *') -> "void":
    return _c3.function_train_core_update_params(arg1, arg2, arg3, arg4)
function_train_core_update_params = _c3.function_train_core_update_params

def function_train_update_params(arg1: 'FunctionTrain', arg2: 'double const *') -> "size_t":
    return _c3.function_train_update_params(arg1, arg2)
function_train_update_params = _c3.function_train_update_params

def function_train_param_grad_sqnorm(arg1: 'FunctionTrain', arg2: 'double *', arg3: 'double *') -> "double":
    return _c3.function_train_param_grad_sqnorm(arg1, arg2, arg3)
function_train_param_grad_sqnorm = _c3.function_train_param_grad_sqnorm

def function_train_eval_ind(arg1: 'FunctionTrain', arg2: 'size_t const *') -> "double":
    return _c3.function_train_eval_ind(arg1, arg2)
function_train_eval_ind = _c3.function_train_eval_ind

def function_train_eval_co_perturb(arg1: 'FunctionTrain', arg2: 'double const *', arg3: 'double const *', arg4: 'double *') -> "double":
    return _c3.function_train_eval_co_perturb(arg1, arg2, arg3, arg4)
function_train_eval_co_perturb = _c3.function_train_eval_co_perturb

def function_train_eval_co_perturb_ind(arg1: 'FunctionTrain', arg2: 'size_t const *', arg3: 'size_t const *', arg4: 'double *') -> "double":
    return _c3.function_train_eval_co_perturb_ind(arg1, arg2, arg3, arg4)
function_train_eval_co_perturb_ind = _c3.function_train_eval_co_perturb_ind

def function_train_eval_fiber_ind(arg1: 'FunctionTrain', arg2: 'size_t const *', arg3: 'size_t', arg4: 'size_t const *', arg5: 'size_t', arg6: 'double *') -> "void":
    return _c3.function_train_eval_fiber_ind(arg1, arg2, arg3, arg4, arg5, arg6)
function_train_eval_fiber_ind = _c3.function_train_eval_fiber_ind

def function_train_poly_randu(arg1: 'enum poly_type', arg2: 'struct BoundingBox *', ranks: 'size_t *', arg4: 'size_t') -> "struct FunctionTrain *":
    return _c3.function_train_poly_randu(arg1, arg2, ranks, arg4)
function_train_poly_randu = _c3.function_train_poly_randu

def function_train_rankone(arg1: 'struct MultiApproxOpts *', arg2: 'struct Fwrap *') -> "struct FunctionTrain *":
    return _c3.function_train_rankone(arg1, arg2)
function_train_rankone = _c3.function_train_rankone

def function_train_initsum(arg1: 'struct MultiApproxOpts *', arg2: 'struct Fwrap *') -> "struct FunctionTrain *":
    return _c3.function_train_initsum(arg1, arg2)
function_train_initsum = _c3.function_train_initsum

def function_train_zeros(arg1: 'struct MultiApproxOpts *', arg2: 'size_t const *') -> "struct FunctionTrain *":
    return _c3.function_train_zeros(arg1, arg2)
function_train_zeros = _c3.function_train_zeros

def function_train_constant(a: 'double', arg2: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_constant(a, arg2)
function_train_constant = _c3.function_train_constant

def function_train_linear(arg1: 'double const *', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_linear(arg1, arg2, arg3, arg4, arg5)
function_train_linear = _c3.function_train_linear

def function_train_linear_update(arg1: 'FunctionTrain', arg2: 'double const *', arg3: 'size_t', arg4: 'double const *', arg5: 'size_t') -> "int":
    return _c3.function_train_linear_update(arg1, arg2, arg3, arg4, arg5)
function_train_linear_update = _c3.function_train_linear_update

def function_train_rankone_prod(arg1: 'double const *', arg2: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_rankone_prod(arg1, arg2)
function_train_rankone_prod = _c3.function_train_rankone_prod

def function_train_quadratic(arg1: 'double const *', arg2: 'double const *', arg3: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_quadratic(arg1, arg2, arg3)
function_train_quadratic = _c3.function_train_quadratic

def function_train_quadratic_aligned(arg1: 'double const *', arg2: 'double const *', arg3: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_quadratic_aligned(arg1, arg2, arg3)
function_train_quadratic_aligned = _c3.function_train_quadratic_aligned

def function_train_create_nodal(arg1: 'FunctionTrain', arg2: 'size_t *', arg3: 'double **') -> "struct FunctionTrain *":
    return _c3.function_train_create_nodal(arg1, arg2, arg3)
function_train_create_nodal = _c3.function_train_create_nodal

def function_train_integrate(arg1: 'FunctionTrain') -> "double":
    return _c3.function_train_integrate(arg1)
function_train_integrate = _c3.function_train_integrate

def function_train_integrate_weighted(arg1: 'FunctionTrain') -> "double":
    return _c3.function_train_integrate_weighted(arg1)
function_train_integrate_weighted = _c3.function_train_integrate_weighted

def function_train_integrate_weighted_subset(ft: 'FunctionTrain', arg2: 'size_t', arg3: 'size_t *') -> "struct FunctionTrain *":
    return _c3.function_train_integrate_weighted_subset(ft, arg2, arg3)
function_train_integrate_weighted_subset = _c3.function_train_integrate_weighted_subset

def function_train_inner(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "double":
    return _c3.function_train_inner(arg1, arg2)
function_train_inner = _c3.function_train_inner

def function_train_inner_weighted(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "double":
    return _c3.function_train_inner_weighted(arg1, arg2)
function_train_inner_weighted = _c3.function_train_inner_weighted

def function_train_norm2(arg1: 'FunctionTrain') -> "double":
    return _c3.function_train_norm2(arg1)
function_train_norm2 = _c3.function_train_norm2

def function_train_orthor(arg1: 'FunctionTrain', arg2: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_orthor(arg1, arg2)
function_train_orthor = _c3.function_train_orthor

def function_train_round(arg1: 'FunctionTrain', arg2: 'double', arg3: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_round(arg1, arg2, arg3)
function_train_round = _c3.function_train_round

def function_train_truncate(arg1: 'FunctionTrain', arg2: 'double') -> "void":
    return _c3.function_train_truncate(arg1, arg2)
function_train_truncate = _c3.function_train_truncate

def function_train_sum(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "struct FunctionTrain *":
    return _c3.function_train_sum(arg1, arg2)
function_train_sum = _c3.function_train_sum

def function_train_scale(arg1: 'FunctionTrain', arg2: 'double') -> "void":
    return _c3.function_train_scale(arg1, arg2)
function_train_scale = _c3.function_train_scale

def function_train_product(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "struct FunctionTrain *":
    return _c3.function_train_product(arg1, arg2)
function_train_product = _c3.function_train_product

def function_train_norm2diff(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "double":
    return _c3.function_train_norm2diff(arg1, arg2)
function_train_norm2diff = _c3.function_train_norm2diff

def function_train_relnorm2diff(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "double":
    return _c3.function_train_relnorm2diff(arg1, arg2)
function_train_relnorm2diff = _c3.function_train_relnorm2diff

def function_train_is_kristoffel_active(arg1: 'FunctionTrain') -> "int":
    return _c3.function_train_is_kristoffel_active(arg1)
function_train_is_kristoffel_active = _c3.function_train_is_kristoffel_active

def function_train_activate_kristoffel(arg1: 'FunctionTrain') -> "void":
    return _c3.function_train_activate_kristoffel(arg1)
function_train_activate_kristoffel = _c3.function_train_activate_kristoffel

def function_train_deactivate_kristoffel(arg1: 'FunctionTrain') -> "void":
    return _c3.function_train_deactivate_kristoffel(arg1)
function_train_deactivate_kristoffel = _c3.function_train_deactivate_kristoffel

def function_train_get_kristoffel_weight(arg1: 'FunctionTrain', arg2: 'double const *') -> "double":
    return _c3.function_train_get_kristoffel_weight(arg1, arg2)
function_train_get_kristoffel_weight = _c3.function_train_get_kristoffel_weight

def ft_cross_args_alloc(arg1: 'size_t', arg2: 'size_t') -> "struct FtCrossArgs *":
    return _c3.ft_cross_args_alloc(arg1, arg2)
ft_cross_args_alloc = _c3.ft_cross_args_alloc

def ft_cross_args_set_rank(arg1: 'struct FtCrossArgs *', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.ft_cross_args_set_rank(arg1, arg2, arg3)
ft_cross_args_set_rank = _c3.ft_cross_args_set_rank

def ft_cross_args_set_round_tol(arg1: 'struct FtCrossArgs *', arg2: 'double') -> "void":
    return _c3.ft_cross_args_set_round_tol(arg1, arg2)
ft_cross_args_set_round_tol = _c3.ft_cross_args_set_round_tol

def ft_cross_args_set_kickrank(arg1: 'struct FtCrossArgs *', arg2: 'size_t') -> "void":
    return _c3.ft_cross_args_set_kickrank(arg1, arg2)
ft_cross_args_set_kickrank = _c3.ft_cross_args_set_kickrank

def ft_cross_args_set_maxiter(arg1: 'struct FtCrossArgs *', arg2: 'size_t') -> "void":
    return _c3.ft_cross_args_set_maxiter(arg1, arg2)
ft_cross_args_set_maxiter = _c3.ft_cross_args_set_maxiter

def ft_cross_args_set_no_adaptation(arg1: 'struct FtCrossArgs *') -> "void":
    return _c3.ft_cross_args_set_no_adaptation(arg1)
ft_cross_args_set_no_adaptation = _c3.ft_cross_args_set_no_adaptation

def ft_cross_args_set_adaptation(arg1: 'struct FtCrossArgs *') -> "void":
    return _c3.ft_cross_args_set_adaptation(arg1)
ft_cross_args_set_adaptation = _c3.ft_cross_args_set_adaptation

def ft_cross_args_set_maxrank_all(arg1: 'struct FtCrossArgs *', arg2: 'size_t') -> "void":
    return _c3.ft_cross_args_set_maxrank_all(arg1, arg2)
ft_cross_args_set_maxrank_all = _c3.ft_cross_args_set_maxrank_all

def ft_cross_args_set_maxrank_ind(arg1: 'struct FtCrossArgs *', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.ft_cross_args_set_maxrank_ind(arg1, arg2, arg3)
ft_cross_args_set_maxrank_ind = _c3.ft_cross_args_set_maxrank_ind

def ft_cross_args_set_cross_tol(arg1: 'struct FtCrossArgs *', arg2: 'double') -> "void":
    return _c3.ft_cross_args_set_cross_tol(arg1, arg2)
ft_cross_args_set_cross_tol = _c3.ft_cross_args_set_cross_tol

def ft_cross_args_set_verbose(arg1: 'struct FtCrossArgs *', arg2: 'int') -> "void":
    return _c3.ft_cross_args_set_verbose(arg1, arg2)
ft_cross_args_set_verbose = _c3.ft_cross_args_set_verbose

def ft_cross_args_get_ranks(arg1: 'struct FtCrossArgs const *') -> "size_t *":
    return _c3.ft_cross_args_get_ranks(arg1)
ft_cross_args_get_ranks = _c3.ft_cross_args_get_ranks

def function_train_get_rank(arg1: 'FunctionTrain', arg2: 'size_t') -> "size_t":
    return _c3.function_train_get_rank(arg1, arg2)
function_train_get_rank = _c3.function_train_get_rank

def ft_cross_args_copy(arg1: 'struct FtCrossArgs const *') -> "struct FtCrossArgs *":
    return _c3.ft_cross_args_copy(arg1)
ft_cross_args_copy = _c3.ft_cross_args_copy

def ft_cross_args_free(arg1: 'struct FtCrossArgs *') -> "void":
    return _c3.ft_cross_args_free(arg1)
ft_cross_args_free = _c3.ft_cross_args_free

def function_train_init_from_fibers(arg1: 'struct Fwrap *', arg2: 'size_t *', arg3: 'struct CrossIndex **', arg4: 'struct CrossIndex **', arg5: 'struct MultiApproxOpts *') -> "struct FunctionTrain *":
    return _c3.function_train_init_from_fibers(arg1, arg2, arg3, arg4, arg5)
function_train_init_from_fibers = _c3.function_train_init_from_fibers

def ftapprox_cross(arg1: 'struct Fwrap *', arg2: 'struct FtCrossArgs *', arg3: 'struct CrossIndex **', arg4: 'struct CrossIndex **', arg5: 'struct MultiApproxOpts *', arg6: 'struct FiberOptArgs *', arg7: 'FunctionTrain') -> "struct FunctionTrain *":
    return _c3.ftapprox_cross(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
ftapprox_cross = _c3.ftapprox_cross

def ftapprox_cross_rankadapt(arg1: 'struct Fwrap *', arg2: 'struct FtCrossArgs *', arg3: 'struct CrossIndex **', arg4: 'struct CrossIndex **', arg5: 'struct MultiApproxOpts *', arg6: 'struct FiberOptArgs *', arg7: 'FunctionTrain') -> "struct FunctionTrain *":
    return _c3.ftapprox_cross_rankadapt(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
ftapprox_cross_rankadapt = _c3.ftapprox_cross_rankadapt
class FT1DArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FT1DArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FT1DArray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _c3.FT1DArray_size_set
    __swig_getmethods__["size"] = _c3.FT1DArray_size_get
    if _newclass:
        size = _swig_property(_c3.FT1DArray_size_get, _c3.FT1DArray_size_set)
    __swig_setmethods__["ft"] = _c3.FT1DArray_ft_set
    __swig_getmethods__["ft"] = _c3.FT1DArray_ft_get
    if _newclass:
        ft = _swig_property(_c3.FT1DArray_ft_get, _c3.FT1DArray_ft_set)

    def __init__(self):
        this = _c3.new_FT1DArray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_FT1DArray
    __del__ = lambda self: None
FT1DArray_swigregister = _c3.FT1DArray_swigregister
FT1DArray_swigregister(FT1DArray)


def ft1d_array_alloc(arg1: 'size_t') -> "struct FT1DArray *":
    return _c3.ft1d_array_alloc(arg1)
ft1d_array_alloc = _c3.ft1d_array_alloc

def function_train_gradient(arg1: 'FunctionTrain') -> "struct FT1DArray *":
    return _c3.function_train_gradient(arg1)
function_train_gradient = _c3.function_train_gradient

def ft1d_array_serialize(arg1: 'unsigned char *', arg2: 'FT1DArray', arg3: 'size_t *') -> "unsigned char *":
    return _c3.ft1d_array_serialize(arg1, arg2, arg3)
ft1d_array_serialize = _c3.ft1d_array_serialize

def ft1d_array_deserialize(arg1: 'unsigned char *', arg2: 'struct FT1DArray **') -> "unsigned char *":
    return _c3.ft1d_array_deserialize(arg1, arg2)
ft1d_array_deserialize = _c3.ft1d_array_deserialize

def ft1d_array_save(arg1: 'FT1DArray', arg2: 'char *') -> "int":
    return _c3.ft1d_array_save(arg1, arg2)
ft1d_array_save = _c3.ft1d_array_save

def ft1d_array_load(arg1: 'char *') -> "struct FT1DArray *":
    return _c3.ft1d_array_load(arg1)
ft1d_array_load = _c3.ft1d_array_load

def ft1d_array_copy(arg1: 'FT1DArray') -> "struct FT1DArray *":
    return _c3.ft1d_array_copy(arg1)
ft1d_array_copy = _c3.ft1d_array_copy

def ft1d_array_free(arg1: 'FT1DArray') -> "void":
    return _c3.ft1d_array_free(arg1)
ft1d_array_free = _c3.ft1d_array_free

def ft1d_array_jacobian(arg1: 'FT1DArray') -> "struct FT1DArray *":
    return _c3.ft1d_array_jacobian(arg1)
ft1d_array_jacobian = _c3.ft1d_array_jacobian

def function_train_hessian(arg1: 'FunctionTrain') -> "struct FT1DArray *":
    return _c3.function_train_hessian(arg1)
function_train_hessian = _c3.function_train_hessian

def function_train_hessian_diag(arg1: 'FunctionTrain') -> "struct FT1DArray *":
    return _c3.function_train_hessian_diag(arg1)
function_train_hessian_diag = _c3.function_train_hessian_diag

def function_train_hessian_diag_periodic(arg1: 'FunctionTrain') -> "struct FT1DArray *":
    return _c3.function_train_hessian_diag_periodic(arg1)
function_train_hessian_diag_periodic = _c3.function_train_hessian_diag_periodic

def ft1d_array_scale(arg1: 'FT1DArray', arg2: 'size_t', arg3: 'size_t', arg4: 'double') -> "void":
    return _c3.ft1d_array_scale(arg1, arg2, arg3, arg4)
ft1d_array_scale = _c3.ft1d_array_scale

def ft1d_array_eval(arg1: 'FT1DArray', arg2: 'double const *') -> "double *":
    return _c3.ft1d_array_eval(arg1, arg2)
ft1d_array_eval = _c3.ft1d_array_eval

def ft1d_array_eval2(arg1: 'FT1DArray', arg2: 'double const *', arg3: 'double *') -> "void":
    return _c3.ft1d_array_eval2(arg1, arg2, arg3)
ft1d_array_eval2 = _c3.ft1d_array_eval2

def c3axpy(arg1: 'double', arg2: 'FunctionTrain', arg3: 'struct FunctionTrain **', arg4: 'double') -> "void":
    return _c3.c3axpy(arg1, arg2, arg3, arg4)
c3axpy = _c3.c3axpy

def c3vaxpy_arr(arg1: 'size_t', arg2: 'double', arg3: 'FT1DArray', arg4: 'size_t', arg5: 'double *', arg6: 'size_t', arg7: 'double', arg8: 'struct FunctionTrain **', arg9: 'double') -> "void":
    return _c3.c3vaxpy_arr(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
c3vaxpy_arr = _c3.c3vaxpy_arr

def c3dot(arg1: 'FunctionTrain', arg2: 'FunctionTrain') -> "double":
    return _c3.c3dot(arg1, arg2)
c3dot = _c3.c3dot

def c3gemv(arg1: 'double', arg2: 'size_t', arg3: 'FT1DArray', arg4: 'size_t', arg5: 'FunctionTrain', arg6: 'double', arg7: 'FunctionTrain', arg8: 'double') -> "void":
    return _c3.c3gemv(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
c3gemv = _c3.c3gemv

def c3vaxpy(arg1: 'size_t', arg2: 'double', arg3: 'FT1DArray', arg4: 'size_t', arg5: 'struct FT1DArray **', arg6: 'size_t', arg7: 'double') -> "void":
    return _c3.c3vaxpy(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
c3vaxpy = _c3.c3vaxpy

def c3vprodsum(arg1: 'size_t', arg2: 'double', arg3: 'FT1DArray', arg4: 'size_t', arg5: 'FT1DArray', arg6: 'size_t', arg7: 'double', arg8: 'struct FunctionTrain **', arg9: 'double') -> "void":
    return _c3.c3vprodsum(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
c3vprodsum = _c3.c3vprodsum

def c3vgemv(arg1: 'size_t', arg2: 'size_t', arg3: 'double', arg4: 'FT1DArray', arg5: 'size_t', arg6: 'FT1DArray', arg7: 'size_t', arg8: 'double', arg9: 'struct FT1DArray **', arg10: 'size_t', arg11: 'double') -> "void":
    return _c3.c3vgemv(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
c3vgemv = _c3.c3vgemv

def c3vgemv_arr(arg1: 'int', arg2: 'size_t', arg3: 'size_t', arg4: 'double', arg5: 'double *', arg6: 'size_t', arg7: 'FT1DArray', arg8: 'size_t', arg9: 'double', arg10: 'struct FT1DArray **', arg11: 'size_t', arg12: 'double') -> "void":
    return _c3.c3vgemv_arr(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
c3vgemv_arr = _c3.c3vgemv_arr
class CrossIndex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CrossIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CrossIndex, name)
    __repr__ = _swig_repr
    __swig_setmethods__["d"] = _c3.CrossIndex_d_set
    __swig_getmethods__["d"] = _c3.CrossIndex_d_get
    if _newclass:
        d = _swig_property(_c3.CrossIndex_d_get, _c3.CrossIndex_d_set)
    __swig_setmethods__["n"] = _c3.CrossIndex_n_set
    __swig_getmethods__["n"] = _c3.CrossIndex_n_get
    if _newclass:
        n = _swig_property(_c3.CrossIndex_n_get, _c3.CrossIndex_n_set)
    __swig_setmethods__["nodes"] = _c3.CrossIndex_nodes_set
    __swig_getmethods__["nodes"] = _c3.CrossIndex_nodes_get
    if _newclass:
        nodes = _swig_property(_c3.CrossIndex_nodes_get, _c3.CrossIndex_nodes_set)

    def __init__(self):
        this = _c3.new_CrossIndex()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_CrossIndex
    __del__ = lambda self: None
CrossIndex_swigregister = _c3.CrossIndex_swigregister
CrossIndex_swigregister(CrossIndex)


def cross_index_alloc(arg1: 'size_t') -> "struct CrossIndex *":
    return _c3.cross_index_alloc(arg1)
cross_index_alloc = _c3.cross_index_alloc

def cross_index_free(arg1: 'CrossIndex') -> "void":
    return _c3.cross_index_free(arg1)
cross_index_free = _c3.cross_index_free

def cross_index_copy(arg1: 'CrossIndex') -> "struct CrossIndex *":
    return _c3.cross_index_copy(arg1)
cross_index_copy = _c3.cross_index_copy

def cross_index_add_index(arg1: 'CrossIndex', arg2: 'size_t', arg3: 'void *', arg4: 'size_t') -> "void":
    return _c3.cross_index_add_index(arg1, arg2, arg3, arg4)
cross_index_add_index = _c3.cross_index_add_index

def cross_index_add_nested(arg1: 'CrossIndex', arg2: 'int', arg3: 'size_t', arg4: 'void *', arg5: 'size_t', arg6: 'void *', arg7: 'size_t') -> "void":
    return _c3.cross_index_add_nested(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
cross_index_add_nested = _c3.cross_index_add_nested

def cross_index_get_node_value(arg1: 'CrossIndex', arg2: 'size_t', arg3: 'size_t *') -> "void *":
    return _c3.cross_index_get_node_value(arg1, arg2, arg3)
cross_index_get_node_value = _c3.cross_index_get_node_value

def cross_index_create_nested(arg1: 'int', arg2: 'int', arg3: 'size_t', arg4: 'size_t', arg5: 'void *', arg6: 'CrossIndex') -> "struct CrossIndex *":
    return _c3.cross_index_create_nested(arg1, arg2, arg3, arg4, arg5, arg6)
cross_index_create_nested = _c3.cross_index_create_nested

def cross_index_create_nested_ind(arg1: 'int', arg2: 'size_t', arg3: 'size_t *', arg4: 'void *', arg5: 'CrossIndex') -> "struct CrossIndex *":
    return _c3.cross_index_create_nested_ind(arg1, arg2, arg3, arg4, arg5)
cross_index_create_nested_ind = _c3.cross_index_create_nested_ind

def cross_index_merge_wspace(arg1: 'CrossIndex', arg2: 'CrossIndex') -> "double **":
    return _c3.cross_index_merge_wspace(arg1, arg2)
cross_index_merge_wspace = _c3.cross_index_merge_wspace

def cross_index_merge(arg1: 'CrossIndex', arg2: 'CrossIndex') -> "double **":
    return _c3.cross_index_merge(arg1, arg2)
cross_index_merge = _c3.cross_index_merge

def cross_index_array_initialize(arg1: 'size_t', arg2: 'struct CrossIndex **', arg3: 'int', arg4: 'int', arg5: 'size_t *', arg6: 'void **', arg7: 'size_t') -> "void":
    return _c3.cross_index_array_initialize(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
cross_index_array_initialize = _c3.cross_index_array_initialize

def cross_index_copylast(arg1: 'CrossIndex', arg2: 'size_t') -> "void":
    return _c3.cross_index_copylast(arg1, arg2)
cross_index_copylast = _c3.cross_index_copylast

def print_cross_index(arg1: 'CrossIndex') -> "void":
    return _c3.print_cross_index(arg1)
print_cross_index = _c3.print_cross_index
class Qmarray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Qmarray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Qmarray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nrows"] = _c3.Qmarray_nrows_set
    __swig_getmethods__["nrows"] = _c3.Qmarray_nrows_get
    if _newclass:
        nrows = _swig_property(_c3.Qmarray_nrows_get, _c3.Qmarray_nrows_set)
    __swig_setmethods__["ncols"] = _c3.Qmarray_ncols_set
    __swig_getmethods__["ncols"] = _c3.Qmarray_ncols_get
    if _newclass:
        ncols = _swig_property(_c3.Qmarray_ncols_get, _c3.Qmarray_ncols_set)
    __swig_setmethods__["funcs"] = _c3.Qmarray_funcs_set
    __swig_getmethods__["funcs"] = _c3.Qmarray_funcs_get
    if _newclass:
        funcs = _swig_property(_c3.Qmarray_funcs_get, _c3.Qmarray_funcs_set)

    def __init__(self):
        this = _c3.new_Qmarray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_Qmarray
    __del__ = lambda self: None
Qmarray_swigregister = _c3.Qmarray_swigregister
Qmarray_swigregister(Qmarray)


def qmarray_alloc(arg1: 'size_t', arg2: 'size_t') -> "struct Qmarray *":
    return _c3.qmarray_alloc(arg1, arg2)
qmarray_alloc = _c3.qmarray_alloc

def qmarray_free(arg1: 'Qmarray') -> "void":
    return _c3.qmarray_free(arg1)
qmarray_free = _c3.qmarray_free

def qmarray_copy(arg1: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_copy(arg1)
qmarray_copy = _c3.qmarray_copy

def qmarray_operate_elements(arg1: 'Qmarray', arg2: 'Operator') -> "struct Qmarray *":
    return _c3.qmarray_operate_elements(arg1, arg2)
qmarray_operate_elements = _c3.qmarray_operate_elements

def qmarray_serialize(arg1: 'unsigned char *', arg2: 'Qmarray', arg3: 'size_t *') -> "unsigned char *":
    return _c3.qmarray_serialize(arg1, arg2, arg3)
qmarray_serialize = _c3.qmarray_serialize

def qmarray_deserialize(arg1: 'unsigned char *', arg2: 'struct Qmarray **') -> "unsigned char *":
    return _c3.qmarray_deserialize(arg1, arg2)
qmarray_deserialize = _c3.qmarray_deserialize

def qmarray_savetxt(arg1: 'Qmarray', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.qmarray_savetxt(arg1, arg2, arg3)
qmarray_savetxt = _c3.qmarray_savetxt

def qmarray_loadtxt(arg1: 'FILE *') -> "struct Qmarray *":
    return _c3.qmarray_loadtxt(arg1)
qmarray_loadtxt = _c3.qmarray_loadtxt

def qmarray_approx1d(arg1: 'size_t', arg2: 'size_t', arg3: 'OneApproxOpts', arg4: 'struct Fwrap *') -> "struct Qmarray *":
    return _c3.qmarray_approx1d(arg1, arg2, arg3, arg4)
qmarray_approx1d = _c3.qmarray_approx1d

def qmarray_orth1d_rows(arg1: 'size_t', arg2: 'size_t', arg3: 'OneApproxOpts') -> "struct Qmarray *":
    return _c3.qmarray_orth1d_rows(arg1, arg2, arg3)
qmarray_orth1d_rows = _c3.qmarray_orth1d_rows

def qmarray_orth1d_columns(arg1: 'size_t', arg2: 'size_t', arg3: 'OneApproxOpts') -> "struct Qmarray *":
    return _c3.qmarray_orth1d_columns(arg1, arg2, arg3)
qmarray_orth1d_columns = _c3.qmarray_orth1d_columns

def qmarray_zeros(arg1: 'size_t', arg2: 'size_t', arg3: 'OneApproxOpts') -> "struct Qmarray *":
    return _c3.qmarray_zeros(arg1, arg2, arg3)
qmarray_zeros = _c3.qmarray_zeros

def qmarray_poly_randu(arg1: 'enum poly_type', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'double', arg6: 'double') -> "struct Qmarray *":
    return _c3.qmarray_poly_randu(arg1, arg2, arg3, arg4, arg5, arg6)
qmarray_poly_randu = _c3.qmarray_poly_randu

def qmarray_get_func_base(arg1: 'Qmarray', arg2: 'size_t', arg3: 'size_t') -> "void *":
    return _c3.qmarray_get_func_base(arg1, arg2, arg3)
qmarray_get_func_base = _c3.qmarray_get_func_base

def qmarray_get_func(arg1: 'Qmarray', arg2: 'size_t', arg3: 'size_t') -> "struct GenericFunction *":
    return _c3.qmarray_get_func(arg1, arg2, arg3)
qmarray_get_func = _c3.qmarray_get_func

def qmarray_set_row(arg1: 'Qmarray', arg2: 'size_t', arg3: 'struct Quasimatrix const *') -> "void":
    return _c3.qmarray_set_row(arg1, arg2, arg3)
qmarray_set_row = _c3.qmarray_set_row

def qmarray_extract_row(arg1: 'Qmarray', arg2: 'size_t') -> "struct Quasimatrix *":
    return _c3.qmarray_extract_row(arg1, arg2)
qmarray_extract_row = _c3.qmarray_extract_row

def qmarray_set_column(arg1: 'Qmarray', arg2: 'size_t', arg3: 'struct Quasimatrix const *') -> "void":
    return _c3.qmarray_set_column(arg1, arg2, arg3)
qmarray_set_column = _c3.qmarray_set_column

def qmarray_set_column_gf(arg1: 'Qmarray', arg2: 'size_t', arg3: 'struct GenericFunction **') -> "void":
    return _c3.qmarray_set_column_gf(arg1, arg2, arg3)
qmarray_set_column_gf = _c3.qmarray_set_column_gf

def qmarray_extract_column(arg1: 'Qmarray', arg2: 'size_t') -> "struct Quasimatrix *":
    return _c3.qmarray_extract_column(arg1, arg2)
qmarray_extract_column = _c3.qmarray_extract_column

def qmarray_get_ncols(arg1: 'Qmarray') -> "size_t":
    return _c3.qmarray_get_ncols(arg1)
qmarray_get_ncols = _c3.qmarray_get_ncols

def qmarray_get_nrows(arg1: 'Qmarray') -> "size_t":
    return _c3.qmarray_get_nrows(arg1)
qmarray_get_nrows = _c3.qmarray_get_nrows

def qmam(arg1: 'Qmarray', arg2: 'double const *', arg3: 'size_t') -> "struct Qmarray *":
    return _c3.qmam(arg1, arg2, arg3)
qmam = _c3.qmam

def qmatm(arg1: 'Qmarray', arg2: 'double const *', arg3: 'size_t') -> "struct Qmarray *":
    return _c3.qmatm(arg1, arg2, arg3)
qmatm = _c3.qmatm

def mqma(arg1: 'double const *', arg2: 'Qmarray', arg3: 'size_t') -> "struct Qmarray *":
    return _c3.mqma(arg1, arg2, arg3)
mqma = _c3.mqma

def qmaqma(a: 'Qmarray', b: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmaqma(a, b)
qmaqma = _c3.qmaqma

def qmatqma(a: 'Qmarray', b: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmatqma(a, b)
qmatqma = _c3.qmatqma

def qmaqmat(a: 'Qmarray', b: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmaqmat(a, b)
qmaqmat = _c3.qmaqmat

def qmatqmat(a: 'Qmarray', b: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmatqmat(a, b)
qmatqmat = _c3.qmatqmat

def qmatqma_integrate(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmatqma_integrate(arg1, arg2)
qmatqma_integrate = _c3.qmatqma_integrate

def qmaqmat_integrate(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmaqmat_integrate(arg1, arg2)
qmaqmat_integrate = _c3.qmaqmat_integrate

def qmatqmat_integrate_weighted(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmatqmat_integrate_weighted(arg1, arg2)
qmatqmat_integrate_weighted = _c3.qmatqmat_integrate_weighted

def qmatqmat_integrate(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmatqmat_integrate(arg1, arg2)
qmatqmat_integrate = _c3.qmatqmat_integrate

def qmarray_kron(arg1: 'Qmarray', arg2: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_kron(arg1, arg2)
qmarray_kron = _c3.qmarray_kron

def qmarray_kron_integrate(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmarray_kron_integrate(arg1, arg2)
qmarray_kron_integrate = _c3.qmarray_kron_integrate

def qmarray_kron_integrate_weighted(arg1: 'Qmarray', arg2: 'Qmarray') -> "double *":
    return _c3.qmarray_kron_integrate_weighted(arg1, arg2)
qmarray_kron_integrate_weighted = _c3.qmarray_kron_integrate_weighted

def qmarray_vec_kron(arg1: 'double const *', arg2: 'Qmarray', arg3: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_vec_kron(arg1, arg2, arg3)
qmarray_vec_kron = _c3.qmarray_vec_kron

def qmarray_vec_kron_integrate(arg1: 'double const *', arg2: 'Qmarray', arg3: 'Qmarray') -> "double *":
    return _c3.qmarray_vec_kron_integrate(arg1, arg2, arg3)
qmarray_vec_kron_integrate = _c3.qmarray_vec_kron_integrate

def qmarray_vec_kron_integrate_weighted(arg1: 'double const *', arg2: 'Qmarray', arg3: 'Qmarray') -> "double *":
    return _c3.qmarray_vec_kron_integrate_weighted(arg1, arg2, arg3)
qmarray_vec_kron_integrate_weighted = _c3.qmarray_vec_kron_integrate_weighted

def qmarray_mat_kron(arg1: 'size_t', arg2: 'double const *', arg3: 'Qmarray', arg4: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_mat_kron(arg1, arg2, arg3, arg4)
qmarray_mat_kron = _c3.qmarray_mat_kron

def qmarray_kron_mat(arg1: 'size_t', arg2: 'double const *', arg3: 'Qmarray', arg4: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_kron_mat(arg1, arg2, arg3, arg4)
qmarray_kron_mat = _c3.qmarray_kron_mat

def qmarray_block_kron_mat(arg1: 'char', arg2: 'int', arg3: 'size_t', arg4: 'struct Qmarray **', arg5: 'Qmarray', arg6: 'size_t', arg7: 'double *', arg8: 'Qmarray') -> "void":
    return _c3.qmarray_block_kron_mat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
qmarray_block_kron_mat = _c3.qmarray_block_kron_mat

def qmarray_integrate(arg1: 'Qmarray') -> "double *":
    return _c3.qmarray_integrate(arg1)
qmarray_integrate = _c3.qmarray_integrate

def qmarray_integrate_weighted(arg1: 'Qmarray') -> "double *":
    return _c3.qmarray_integrate_weighted(arg1)
qmarray_integrate_weighted = _c3.qmarray_integrate_weighted

def qmarray_norm2diff(arg1: 'Qmarray', arg2: 'Qmarray') -> "double":
    return _c3.qmarray_norm2diff(arg1, arg2)
qmarray_norm2diff = _c3.qmarray_norm2diff

def qmarray_norm2(arg1: 'Qmarray') -> "double":
    return _c3.qmarray_norm2(arg1)
qmarray_norm2 = _c3.qmarray_norm2

def qmarray_axpy(arg1: 'double', arg2: 'Qmarray', arg3: 'Qmarray') -> "void":
    return _c3.qmarray_axpy(arg1, arg2, arg3)
qmarray_axpy = _c3.qmarray_axpy

def qmarray_lu1d(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'double *', arg4: 'size_t *', arg5: 'double *', arg6: 'OneApproxOpts', arg7: 'void *') -> "int":
    return _c3.qmarray_lu1d(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
qmarray_lu1d = _c3.qmarray_lu1d

def qmarray_maxvol1d(arg1: 'Qmarray', arg2: 'double *', arg3: 'size_t *', arg4: 'double *', arg5: 'OneApproxOpts', arg6: 'void *') -> "int":
    return _c3.qmarray_maxvol1d(arg1, arg2, arg3, arg4, arg5, arg6)
qmarray_maxvol1d = _c3.qmarray_maxvol1d

def qmarray_qhouse(arg1: 'Qmarray', arg2: 'Qmarray') -> "int":
    return _c3.qmarray_qhouse(arg1, arg2)
qmarray_qhouse = _c3.qmarray_qhouse

def qmarray_qhouse_rows(arg1: 'Qmarray', arg2: 'Qmarray') -> "int":
    return _c3.qmarray_qhouse_rows(arg1, arg2)
qmarray_qhouse_rows = _c3.qmarray_qhouse_rows

def qmarray_householder(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'double *') -> "int":
    return _c3.qmarray_householder(arg1, arg2, arg3, arg4)
qmarray_householder = _c3.qmarray_householder

def qmarray_householder_rows(arg1: 'Qmarray', arg2: 'Qmarray', arg3: 'Qmarray', arg4: 'double *') -> "int":
    return _c3.qmarray_householder_rows(arg1, arg2, arg3, arg4)
qmarray_householder_rows = _c3.qmarray_householder_rows

def qmarray_householder_simple(arg1: 'char *', arg2: 'Qmarray', arg3: 'double *', arg4: 'OneApproxOpts') -> "struct Qmarray *":
    return _c3.qmarray_householder_simple(arg1, arg2, arg3, arg4)
qmarray_householder_simple = _c3.qmarray_householder_simple

def qmarray_svd(arg1: 'Qmarray', arg2: 'struct Qmarray **', arg3: 'double *', arg4: 'double *', arg5: 'OneApproxOpts') -> "int":
    return _c3.qmarray_svd(arg1, arg2, arg3, arg4, arg5)
qmarray_svd = _c3.qmarray_svd

def qmarray_truncated_svd(arg1: 'Qmarray', arg2: 'struct Qmarray **', arg3: 'double **', arg4: 'double **', arg5: 'double', arg6: 'OneApproxOpts') -> "size_t":
    return _c3.qmarray_truncated_svd(arg1, arg2, arg3, arg4, arg5, arg6)
qmarray_truncated_svd = _c3.qmarray_truncated_svd

def qmarray_absmax1d(arg1: 'Qmarray', arg2: 'double *', arg3: 'size_t *', arg4: 'size_t *', arg5: 'double *', arg6: 'void *') -> "void":
    return _c3.qmarray_absmax1d(arg1, arg2, arg3, arg4, arg5, arg6)
qmarray_absmax1d = _c3.qmarray_absmax1d

def qmarray_transpose(a: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_transpose(a)
qmarray_transpose = _c3.qmarray_transpose

def qmarray_stackh(arg1: 'Qmarray', arg2: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_stackh(arg1, arg2)
qmarray_stackh = _c3.qmarray_stackh

def qmarray_stackv(arg1: 'Qmarray', arg2: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_stackv(arg1, arg2)
qmarray_stackv = _c3.qmarray_stackv

def qmarray_blockdiag(arg1: 'Qmarray', arg2: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_blockdiag(arg1, arg2)
qmarray_blockdiag = _c3.qmarray_blockdiag

def qmarray_deriv(arg1: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_deriv(arg1)
qmarray_deriv = _c3.qmarray_deriv

def qmarray_dderiv(arg1: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_dderiv(arg1)
qmarray_dderiv = _c3.qmarray_dderiv

def qmarray_dderiv_periodic(arg1: 'Qmarray') -> "struct Qmarray *":
    return _c3.qmarray_dderiv_periodic(arg1)
qmarray_dderiv_periodic = _c3.qmarray_dderiv_periodic

def qmarray_deriv_eval(arg1: 'Qmarray', arg2: 'double', arg3: 'double *') -> "void":
    return _c3.qmarray_deriv_eval(arg1, arg2, arg3)
qmarray_deriv_eval = _c3.qmarray_deriv_eval

def qmarray_roundt(arg1: 'struct Qmarray **', arg2: 'double') -> "void":
    return _c3.qmarray_roundt(arg1, arg2)
qmarray_roundt = _c3.qmarray_roundt

def qmarray_eval(arg1: 'Qmarray', arg2: 'double', arg3: 'double *') -> "void":
    return _c3.qmarray_eval(arg1, arg2, arg3)
qmarray_eval = _c3.qmarray_eval

def qmarray_func_get_nparams(arg1: 'Qmarray', arg2: 'size_t', arg3: 'size_t') -> "size_t":
    return _c3.qmarray_func_get_nparams(arg1, arg2, arg3)
qmarray_func_get_nparams = _c3.qmarray_func_get_nparams

def qmarray_get_nparams(arg1: 'Qmarray', arg2: 'size_t *') -> "size_t":
    return _c3.qmarray_get_nparams(arg1, arg2)
qmarray_get_nparams = _c3.qmarray_get_nparams

def qmarray_get_params(arg1: 'Qmarray', arg2: 'double *') -> "size_t":
    return _c3.qmarray_get_params(arg1, arg2)
qmarray_get_params = _c3.qmarray_get_params

def qmarray_uni_update_params(arg1: 'Qmarray', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'double const *') -> "void":
    return _c3.qmarray_uni_update_params(arg1, arg2, arg3, arg4, arg5)
qmarray_uni_update_params = _c3.qmarray_uni_update_params

def qmarray_update_params(arg1: 'Qmarray', arg2: 'size_t', arg3: 'double const *') -> "void":
    return _c3.qmarray_update_params(arg1, arg2, arg3)
qmarray_update_params = _c3.qmarray_update_params

def qmarray_param_grad_eval(arg1: 'Qmarray', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t', arg7: 'double *', arg8: 'size_t', arg9: 'double *') -> "void":
    return _c3.qmarray_param_grad_eval(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
qmarray_param_grad_eval = _c3.qmarray_param_grad_eval

def qmarray_linparam_eval(arg1: 'Qmarray', arg2: 'size_t', arg3: 'double *', arg4: 'size_t', arg5: 'double const *', arg6: 'size_t') -> "void":
    return _c3.qmarray_linparam_eval(arg1, arg2, arg3, arg4, arg5, arg6)
qmarray_linparam_eval = _c3.qmarray_linparam_eval

def qmarray_param_grad_eval_sparse_mult(arg1: 'Qmarray', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t', arg7: 'double *', arg8: 'size_t', arg9: 'double *', arg10: 'double *', arg11: 'size_t') -> "void":
    return _c3.qmarray_param_grad_eval_sparse_mult(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
qmarray_param_grad_eval_sparse_mult = _c3.qmarray_param_grad_eval_sparse_mult

def qmarray_param_grad_sqnorm(arg1: 'Qmarray', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.qmarray_param_grad_sqnorm(arg1, arg2, arg3)
qmarray_param_grad_sqnorm = _c3.qmarray_param_grad_sqnorm

def qmarray_create_nodal(arg1: 'Qmarray', arg2: 'size_t', arg3: 'double *') -> "struct Qmarray *":
    return _c3.qmarray_create_nodal(arg1, arg2, arg3)
qmarray_create_nodal = _c3.qmarray_create_nodal

def qmarray_is_kristoffel_active(arg1: 'Qmarray') -> "int":
    return _c3.qmarray_is_kristoffel_active(arg1)
qmarray_is_kristoffel_active = _c3.qmarray_is_kristoffel_active

def qmarray_activate_kristoffel(arg1: 'Qmarray') -> "void":
    return _c3.qmarray_activate_kristoffel(arg1)
qmarray_activate_kristoffel = _c3.qmarray_activate_kristoffel

def qmarray_deactivate_kristoffel(arg1: 'Qmarray') -> "void":
    return _c3.qmarray_deactivate_kristoffel(arg1)
qmarray_deactivate_kristoffel = _c3.qmarray_deactivate_kristoffel

def qmarray_get_kristoffel_weight(arg1: 'Qmarray', arg2: 'double') -> "double":
    return _c3.qmarray_get_kristoffel_weight(arg1, arg2)
qmarray_get_kristoffel_weight = _c3.qmarray_get_kristoffel_weight

def qmarray_qr(arg1: 'Qmarray', arg2: 'struct Qmarray **', arg3: 'double **', arg4: 'OneApproxOpts') -> "int":
    return _c3.qmarray_qr(arg1, arg2, arg3, arg4)
qmarray_qr = _c3.qmarray_qr

def qmarray_lq(arg1: 'Qmarray', arg2: 'struct Qmarray **', arg3: 'double **', arg4: 'OneApproxOpts') -> "int":
    return _c3.qmarray_lq(arg1, arg2, arg3, arg4)
qmarray_lq = _c3.qmarray_lq

def qmarray_qr_gs(arg1: 'Qmarray', arg2: 'double **') -> "int":
    return _c3.qmarray_qr_gs(arg1, arg2)
qmarray_qr_gs = _c3.qmarray_qr_gs

def qmarray_lq_gs(arg1: 'Qmarray', arg2: 'double **') -> "int":
    return _c3.qmarray_lq_gs(arg1, arg2)
qmarray_lq_gs = _c3.qmarray_lq_gs

def print_qmarray(arg1: 'Qmarray', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_qmarray(arg1, arg2, arg3, arg4)
print_qmarray = _c3.print_qmarray

def quasimatrix_alloc(arg1: 'size_t') -> "struct Quasimatrix *":
    return _c3.quasimatrix_alloc(arg1)
quasimatrix_alloc = _c3.quasimatrix_alloc

def quasimatrix_free_funcs(arg1: 'struct Quasimatrix *') -> "void":
    return _c3.quasimatrix_free_funcs(arg1)
quasimatrix_free_funcs = _c3.quasimatrix_free_funcs

def quasimatrix_free(arg1: 'struct Quasimatrix *') -> "void":
    return _c3.quasimatrix_free(arg1)
quasimatrix_free = _c3.quasimatrix_free

def quasimatrix_get_size(arg1: 'struct Quasimatrix const *') -> "size_t":
    return _c3.quasimatrix_get_size(arg1)
quasimatrix_get_size = _c3.quasimatrix_get_size

def quasimatrix_set_size(arg1: 'struct Quasimatrix *', arg2: 'size_t') -> "void":
    return _c3.quasimatrix_set_size(arg1, arg2)
quasimatrix_set_size = _c3.quasimatrix_set_size

def quasimatrix_get_func(arg1: 'struct Quasimatrix const *', arg2: 'size_t') -> "struct GenericFunction *":
    return _c3.quasimatrix_get_func(arg1, arg2)
quasimatrix_get_func = _c3.quasimatrix_get_func

def quasimatrix_set_func(arg1: 'struct Quasimatrix *', arg2: 'GenericFunction', arg3: 'size_t') -> "void":
    return _c3.quasimatrix_set_func(arg1, arg2, arg3)
quasimatrix_set_func = _c3.quasimatrix_set_func

def quasimatrix_get_funcs(arg1: 'struct Quasimatrix const *') -> "struct GenericFunction **":
    return _c3.quasimatrix_get_funcs(arg1)
quasimatrix_get_funcs = _c3.quasimatrix_get_funcs

def quasimatrix_set_funcs(arg1: 'struct Quasimatrix *', arg2: 'struct GenericFunction **') -> "void":
    return _c3.quasimatrix_set_funcs(arg1, arg2)
quasimatrix_set_funcs = _c3.quasimatrix_set_funcs

def quasimatrix_get_funcs_ref(arg1: 'struct Quasimatrix const *', arg2: 'struct GenericFunction ***') -> "void":
    return _c3.quasimatrix_get_funcs_ref(arg1, arg2)
quasimatrix_get_funcs_ref = _c3.quasimatrix_get_funcs_ref

def quasimatrix_approx1d(arg1: 'size_t', arg2: 'struct Fwrap *', arg3: 'enum function_class *', arg4: 'void *') -> "struct Quasimatrix *":
    return _c3.quasimatrix_approx1d(arg1, arg2, arg3, arg4)
quasimatrix_approx1d = _c3.quasimatrix_approx1d

def quasimatrix_copy(arg1: 'struct Quasimatrix const *') -> "struct Quasimatrix *":
    return _c3.quasimatrix_copy(arg1)
quasimatrix_copy = _c3.quasimatrix_copy

def quasimatrix_serialize(arg1: 'unsigned char *', arg2: 'struct Quasimatrix const *', arg3: 'size_t *') -> "unsigned char *":
    return _c3.quasimatrix_serialize(arg1, arg2, arg3)
quasimatrix_serialize = _c3.quasimatrix_serialize

def quasimatrix_deserialize(arg1: 'unsigned char *', arg2: 'struct Quasimatrix **') -> "unsigned char *":
    return _c3.quasimatrix_deserialize(arg1, arg2)
quasimatrix_deserialize = _c3.quasimatrix_deserialize

def quasimatrix_orth1d(arg1: 'size_t', arg2: 'enum function_class', arg3: 'void *') -> "struct Quasimatrix *":
    return _c3.quasimatrix_orth1d(arg1, arg2, arg3)
quasimatrix_orth1d = _c3.quasimatrix_orth1d

def quasimatrix_absmax(arg1: 'struct Quasimatrix *', arg2: 'double *', arg3: 'double *', arg4: 'void *') -> "size_t":
    return _c3.quasimatrix_absmax(arg1, arg2, arg3, arg4)
quasimatrix_absmax = _c3.quasimatrix_absmax

def quasimatrix_inner(arg1: 'struct Quasimatrix const *', arg2: 'struct Quasimatrix const *') -> "double":
    return _c3.quasimatrix_inner(arg1, arg2)
quasimatrix_inner = _c3.quasimatrix_inner

def qmv(arg1: 'struct Quasimatrix const *', arg2: 'double const *') -> "struct GenericFunction *":
    return _c3.qmv(arg1, arg2)
qmv = _c3.qmv

def qmm(arg1: 'struct Quasimatrix const *', arg2: 'double const *', arg3: 'size_t') -> "struct Quasimatrix *":
    return _c3.qmm(arg1, arg2, arg3)
qmm = _c3.qmm

def qmmt(arg1: 'struct Quasimatrix const *', arg2: 'double const *', arg3: 'size_t') -> "struct Quasimatrix *":
    return _c3.qmmt(arg1, arg2, arg3)
qmmt = _c3.qmmt

def quasimatrix_daxpby(arg1: 'double', arg2: 'struct Quasimatrix const *', arg3: 'double', arg4: 'struct Quasimatrix const *') -> "struct Quasimatrix *":
    return _c3.quasimatrix_daxpby(arg1, arg2, arg3, arg4)
quasimatrix_daxpby = _c3.quasimatrix_daxpby

def quasimatrix_householder_simple(arg1: 'struct Quasimatrix *', arg2: 'double *', arg3: 'void *') -> "struct Quasimatrix *":
    return _c3.quasimatrix_householder_simple(arg1, arg2, arg3)
quasimatrix_householder_simple = _c3.quasimatrix_householder_simple

def quasimatrix_householder(arg1: 'struct Quasimatrix *', arg2: 'struct Quasimatrix *', arg3: 'struct Quasimatrix *', arg4: 'double *') -> "int":
    return _c3.quasimatrix_householder(arg1, arg2, arg3, arg4)
quasimatrix_householder = _c3.quasimatrix_householder

def quasimatrix_qhouse(arg1: 'struct Quasimatrix *', arg2: 'struct Quasimatrix *') -> "int":
    return _c3.quasimatrix_qhouse(arg1, arg2)
quasimatrix_qhouse = _c3.quasimatrix_qhouse

def quasimatrix_lu1d(arg1: 'struct Quasimatrix *', arg2: 'struct Quasimatrix *', arg3: 'double *', arg4: 'double *', arg5: 'void *', arg6: 'void *') -> "int":
    return _c3.quasimatrix_lu1d(arg1, arg2, arg3, arg4, arg5, arg6)
quasimatrix_lu1d = _c3.quasimatrix_lu1d

def quasimatrix_maxvol1d(arg1: 'struct Quasimatrix *', arg2: 'double *', arg3: 'double *', arg4: 'void *', arg5: 'void *') -> "int":
    return _c3.quasimatrix_maxvol1d(arg1, arg2, arg3, arg4, arg5)
quasimatrix_maxvol1d = _c3.quasimatrix_maxvol1d

def quasimatrix_rank(arg1: 'struct Quasimatrix const *', arg2: 'void *') -> "size_t":
    return _c3.quasimatrix_rank(arg1, arg2)
quasimatrix_rank = _c3.quasimatrix_rank

def quasimatrix_norm(arg1: 'struct Quasimatrix const *') -> "double":
    return _c3.quasimatrix_norm(arg1)
quasimatrix_norm = _c3.quasimatrix_norm

def quasimatrix_print(arg1: 'struct Quasimatrix const *', arg2: 'FILE *', arg3: 'size_t', arg4: 'void *') -> "void":
    return _c3.quasimatrix_print(arg1, arg2, arg3, arg4)
quasimatrix_print = _c3.quasimatrix_print
class OneApproxOpts(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OneApproxOpts, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OneApproxOpts, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fc"] = _c3.OneApproxOpts_fc_set
    __swig_getmethods__["fc"] = _c3.OneApproxOpts_fc_get
    if _newclass:
        fc = _swig_property(_c3.OneApproxOpts_fc_get, _c3.OneApproxOpts_fc_set)
    __swig_setmethods__["aopts"] = _c3.OneApproxOpts_aopts_set
    __swig_getmethods__["aopts"] = _c3.OneApproxOpts_aopts_get
    if _newclass:
        aopts = _swig_property(_c3.OneApproxOpts_aopts_get, _c3.OneApproxOpts_aopts_set)

    def __init__(self):
        this = _c3.new_OneApproxOpts()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_OneApproxOpts
    __del__ = lambda self: None
OneApproxOpts_swigregister = _c3.OneApproxOpts_swigregister
OneApproxOpts_swigregister(OneApproxOpts)


def one_approx_opts_alloc(arg1: 'enum function_class', arg2: 'void *') -> "struct OneApproxOpts *":
    return _c3.one_approx_opts_alloc(arg1, arg2)
one_approx_opts_alloc = _c3.one_approx_opts_alloc

def one_approx_opts_free(arg1: 'OneApproxOpts') -> "void":
    return _c3.one_approx_opts_free(arg1)
one_approx_opts_free = _c3.one_approx_opts_free

def one_approx_opts_free_deep(arg1: 'struct OneApproxOpts **') -> "void":
    return _c3.one_approx_opts_free_deep(arg1)
one_approx_opts_free_deep = _c3.one_approx_opts_free_deep

def one_approx_opts_get_nparams(arg1: 'OneApproxOpts') -> "size_t":
    return _c3.one_approx_opts_get_nparams(arg1)
one_approx_opts_get_nparams = _c3.one_approx_opts_get_nparams

def one_approx_opts_set_nparams(arg1: 'OneApproxOpts', arg2: 'size_t') -> "void":
    return _c3.one_approx_opts_set_nparams(arg1, arg2)
one_approx_opts_set_nparams = _c3.one_approx_opts_set_nparams

def one_approx_opts_get_lb(arg1: 'OneApproxOpts') -> "double":
    return _c3.one_approx_opts_get_lb(arg1)
one_approx_opts_get_lb = _c3.one_approx_opts_get_lb

def one_approx_opts_get_ub(arg1: 'OneApproxOpts') -> "double":
    return _c3.one_approx_opts_get_ub(arg1)
one_approx_opts_get_ub = _c3.one_approx_opts_get_ub

def one_approx_opts_linear_p(arg1: 'OneApproxOpts') -> "int":
    return _c3.one_approx_opts_linear_p(arg1)
one_approx_opts_linear_p = _c3.one_approx_opts_linear_p

def multi_approx_opts_alloc(arg1: 'size_t') -> "struct MultiApproxOpts *":
    return _c3.multi_approx_opts_alloc(arg1)
multi_approx_opts_alloc = _c3.multi_approx_opts_alloc

def multi_approx_opts_free(arg1: 'struct MultiApproxOpts *') -> "void":
    return _c3.multi_approx_opts_free(arg1)
multi_approx_opts_free = _c3.multi_approx_opts_free

def multi_approx_opts_free_deep(arg1: 'struct MultiApproxOpts **') -> "void":
    return _c3.multi_approx_opts_free_deep(arg1)
multi_approx_opts_free_deep = _c3.multi_approx_opts_free_deep

def multi_approx_opts_set_dim(arg1: 'struct MultiApproxOpts *', arg2: 'size_t', arg3: 'OneApproxOpts') -> "void":
    return _c3.multi_approx_opts_set_dim(arg1, arg2, arg3)
multi_approx_opts_set_dim = _c3.multi_approx_opts_set_dim

def multi_approx_opts_set_dim_ref(arg1: 'struct MultiApproxOpts *', arg2: 'size_t', arg3: 'struct OneApproxOpts **') -> "void":
    return _c3.multi_approx_opts_set_dim_ref(arg1, arg2, arg3)
multi_approx_opts_set_dim_ref = _c3.multi_approx_opts_set_dim_ref

def multi_approx_opts_set_all_same(arg1: 'struct MultiApproxOpts *', arg2: 'OneApproxOpts') -> "void":
    return _c3.multi_approx_opts_set_all_same(arg1, arg2)
multi_approx_opts_set_all_same = _c3.multi_approx_opts_set_all_same

def multi_approx_opts_get_fc(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "enum function_class":
    return _c3.multi_approx_opts_get_fc(arg1, arg2)
multi_approx_opts_get_fc = _c3.multi_approx_opts_get_fc

def multi_approx_opts_linear_p(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "int":
    return _c3.multi_approx_opts_linear_p(arg1, arg2)
multi_approx_opts_linear_p = _c3.multi_approx_opts_linear_p

def multi_approx_opts_get_aopts(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "void *":
    return _c3.multi_approx_opts_get_aopts(arg1, arg2)
multi_approx_opts_get_aopts = _c3.multi_approx_opts_get_aopts

def multi_approx_opts_get_dim(arg1: 'struct MultiApproxOpts const *') -> "size_t":
    return _c3.multi_approx_opts_get_dim(arg1)
multi_approx_opts_get_dim = _c3.multi_approx_opts_get_dim

def multi_approx_opts_get_dim_nparams(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "size_t":
    return _c3.multi_approx_opts_get_dim_nparams(arg1, arg2)
multi_approx_opts_get_dim_nparams = _c3.multi_approx_opts_get_dim_nparams

def multi_approx_opts_set_dim_nparams(arg1: 'struct MultiApproxOpts *', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.multi_approx_opts_set_dim_nparams(arg1, arg2, arg3)
multi_approx_opts_set_dim_nparams = _c3.multi_approx_opts_set_dim_nparams

def multi_approx_opts_get_dim_ub(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "double":
    return _c3.multi_approx_opts_get_dim_ub(arg1, arg2)
multi_approx_opts_get_dim_ub = _c3.multi_approx_opts_get_dim_ub

def multi_approx_opts_get_dim_lb(arg1: 'struct MultiApproxOpts const *', arg2: 'size_t') -> "double":
    return _c3.multi_approx_opts_get_dim_lb(arg1, arg2)
multi_approx_opts_get_dim_lb = _c3.multi_approx_opts_get_dim_lb

def fiber_opt_args_alloc() -> "struct FiberOptArgs *":
    return _c3.fiber_opt_args_alloc()
fiber_opt_args_alloc = _c3.fiber_opt_args_alloc

def fiber_opt_args_init(arg1: 'size_t') -> "struct FiberOptArgs *":
    return _c3.fiber_opt_args_init(arg1)
fiber_opt_args_init = _c3.fiber_opt_args_init

def fiber_opt_args_set_dim(arg1: 'struct FiberOptArgs *', arg2: 'size_t', arg3: 'void *') -> "void":
    return _c3.fiber_opt_args_set_dim(arg1, arg2, arg3)
fiber_opt_args_set_dim = _c3.fiber_opt_args_set_dim

def fiber_opt_args_bf(arg1: 'size_t', arg2: 'struct c3Vector **') -> "struct FiberOptArgs *":
    return _c3.fiber_opt_args_bf(arg1, arg2)
fiber_opt_args_bf = _c3.fiber_opt_args_bf

def fiber_opt_args_bf_same(arg1: 'size_t', arg2: 'c3Vector') -> "struct FiberOptArgs *":
    return _c3.fiber_opt_args_bf_same(arg1, arg2)
fiber_opt_args_bf_same = _c3.fiber_opt_args_bf_same

def fiber_opt_args_get_opts(arg1: 'struct FiberOptArgs const *', arg2: 'size_t') -> "void *":
    return _c3.fiber_opt_args_get_opts(arg1, arg2)
fiber_opt_args_get_opts = _c3.fiber_opt_args_get_opts

def fiber_opt_args_free(arg1: 'struct FiberOptArgs *') -> "void":
    return _c3.fiber_opt_args_free(arg1)
fiber_opt_args_free = _c3.fiber_opt_args_free
class Operator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Operator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Operator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _c3.Operator_f_set
    __swig_getmethods__["f"] = _c3.Operator_f_get
    if _newclass:
        f = _swig_property(_c3.Operator_f_get, _c3.Operator_f_set)
    __swig_setmethods__["opts"] = _c3.Operator_opts_set
    __swig_getmethods__["opts"] = _c3.Operator_opts_get
    if _newclass:
        opts = _swig_property(_c3.Operator_opts_get, _c3.Operator_opts_set)

    def __init__(self):
        this = _c3.new_Operator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_Operator
    __del__ = lambda self: None
Operator_swigregister = _c3.Operator_swigregister
Operator_swigregister(Operator)

PIECEWISE = _c3.PIECEWISE
POLYNOMIAL = _c3.POLYNOMIAL
CONSTELM = _c3.CONSTELM
LINELM = _c3.LINELM
KERNEL = _c3.KERNEL
PARAMETRIC = _c3.PARAMETRIC
NONPARAMETRIC = _c3.NONPARAMETRIC
LS = _c3.LS
RLS2 = _c3.RLS2
RLSD2 = _c3.RLSD2
RLSRKHS = _c3.RLSRKHS
RLS1 = _c3.RLS1
class GenericFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GenericFunction, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dim"] = _c3.GenericFunction_dim_set
    __swig_getmethods__["dim"] = _c3.GenericFunction_dim_get
    if _newclass:
        dim = _swig_property(_c3.GenericFunction_dim_get, _c3.GenericFunction_dim_set)
    __swig_setmethods__["fc"] = _c3.GenericFunction_fc_set
    __swig_getmethods__["fc"] = _c3.GenericFunction_fc_get
    if _newclass:
        fc = _swig_property(_c3.GenericFunction_fc_get, _c3.GenericFunction_fc_set)
    __swig_setmethods__["f"] = _c3.GenericFunction_f_set
    __swig_getmethods__["f"] = _c3.GenericFunction_f_get
    if _newclass:
        f = _swig_property(_c3.GenericFunction_f_get, _c3.GenericFunction_f_set)
    __swig_setmethods__["fargs"] = _c3.GenericFunction_fargs_set
    __swig_getmethods__["fargs"] = _c3.GenericFunction_fargs_get
    if _newclass:
        fargs = _swig_property(_c3.GenericFunction_fargs_get, _c3.GenericFunction_fargs_set)

    def __init__(self):
        this = _c3.new_GenericFunction()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_GenericFunction
    __del__ = lambda self: None
GenericFunction_swigregister = _c3.GenericFunction_swigregister
GenericFunction_swigregister(GenericFunction)


def generic_function_alloc_base(arg1: 'size_t') -> "struct GenericFunction *":
    return _c3.generic_function_alloc_base(arg1)
generic_function_alloc_base = _c3.generic_function_alloc_base

def generic_function_array_alloc(arg1: 'size_t') -> "struct GenericFunction **":
    return _c3.generic_function_array_alloc(arg1)
generic_function_array_alloc = _c3.generic_function_array_alloc

def generic_function_alloc(arg1: 'size_t', arg2: 'enum function_class') -> "struct GenericFunction *":
    return _c3.generic_function_alloc(arg1, arg2)
generic_function_alloc = _c3.generic_function_alloc

def generic_function_free(arg1: 'GenericFunction') -> "void":
    return _c3.generic_function_free(arg1)
generic_function_free = _c3.generic_function_free

def generic_function_array_free(arg1: 'struct GenericFunction **', arg2: 'size_t') -> "void":
    return _c3.generic_function_array_free(arg1, arg2)
generic_function_array_free = _c3.generic_function_array_free

def generic_function_copy(arg1: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_copy(arg1)
generic_function_copy = _c3.generic_function_copy

def generic_function_copy_pa(arg1: 'GenericFunction', arg2: 'GenericFunction') -> "void":
    return _c3.generic_function_copy_pa(arg1, arg2)
generic_function_copy_pa = _c3.generic_function_copy_pa

def serialize_generic_function(arg1: 'unsigned char *', arg2: 'GenericFunction', arg3: 'size_t *') -> "unsigned char *":
    return _c3.serialize_generic_function(arg1, arg2, arg3)
serialize_generic_function = _c3.serialize_generic_function

def deserialize_generic_function(arg1: 'unsigned char *', arg2: 'struct GenericFunction **') -> "unsigned char *":
    return _c3.deserialize_generic_function(arg1, arg2)
deserialize_generic_function = _c3.deserialize_generic_function

def generic_function_savetxt(arg1: 'GenericFunction', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.generic_function_savetxt(arg1, arg2, arg3)
generic_function_savetxt = _c3.generic_function_savetxt

def generic_function_loadtxt(arg1: 'FILE *') -> "struct GenericFunction *":
    return _c3.generic_function_loadtxt(arg1)
generic_function_loadtxt = _c3.generic_function_loadtxt

def print_generic_function(arg1: 'GenericFunction', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_generic_function(arg1, arg2, arg3, arg4)
print_generic_function = _c3.print_generic_function

def generic_function_approximate1d(arg1: 'enum function_class', arg2: 'void *', arg3: 'struct Fwrap *') -> "struct GenericFunction *":
    return _c3.generic_function_approximate1d(arg1, arg2, arg3)
generic_function_approximate1d = _c3.generic_function_approximate1d

def generic_function_regress1d(arg1: 'struct Regress1DOpts *', arg2: 'struct c3Opt *', arg3: 'int *') -> "struct GenericFunction *":
    return _c3.generic_function_regress1d(arg1, arg2, arg3)
generic_function_regress1d = _c3.generic_function_regress1d

def generic_function_create_with_params(arg1: 'enum function_class', arg2: 'void *', arg3: 'size_t', arg4: 'double const *') -> "struct GenericFunction *":
    return _c3.generic_function_create_with_params(arg1, arg2, arg3, arg4)
generic_function_create_with_params = _c3.generic_function_create_with_params

def generic_function_zero(arg1: 'enum function_class', arg2: 'void *', arg3: 'int') -> "struct GenericFunction *":
    return _c3.generic_function_zero(arg1, arg2, arg3)
generic_function_zero = _c3.generic_function_zero

def generic_function_constant(arg1: 'double', arg2: 'enum function_class', arg3: 'void *') -> "struct GenericFunction *":
    return _c3.generic_function_constant(arg1, arg2, arg3)
generic_function_constant = _c3.generic_function_constant

def generic_function_linear(arg1: 'double', arg2: 'double', arg3: 'enum function_class', arg4: 'void *') -> "struct GenericFunction *":
    return _c3.generic_function_linear(arg1, arg2, arg3, arg4)
generic_function_linear = _c3.generic_function_linear

def generic_function_linear_update(arg1: 'GenericFunction', arg2: 'double', arg3: 'double') -> "int":
    return _c3.generic_function_linear_update(arg1, arg2, arg3)
generic_function_linear_update = _c3.generic_function_linear_update

def generic_function_quadratic(arg1: 'double', arg2: 'double', arg3: 'enum function_class', arg4: 'void *') -> "struct GenericFunction *":
    return _c3.generic_function_quadratic(arg1, arg2, arg3, arg4)
generic_function_quadratic = _c3.generic_function_quadratic

def generic_function_poly_randu(arg1: 'enum poly_type', arg2: 'size_t', arg3: 'double', arg4: 'double') -> "struct GenericFunction *":
    return _c3.generic_function_poly_randu(arg1, arg2, arg3, arg4)
generic_function_poly_randu = _c3.generic_function_poly_randu

def generic_function_onezero(arg1: 'enum function_class', arg2: 'double', arg3: 'size_t', arg4: 'double *', arg5: 'double', arg6: 'double') -> "struct GenericFunction *":
    return _c3.generic_function_onezero(arg1, arg2, arg3, arg4, arg5, arg6)
generic_function_onezero = _c3.generic_function_onezero

def generic_function_lin_comb(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'double const *') -> "struct GenericFunction *":
    return _c3.generic_function_lin_comb(arg1, arg2, arg3)
generic_function_lin_comb = _c3.generic_function_lin_comb

def generic_function_lin_comb2(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'size_t', arg5: 'double const *') -> "struct GenericFunction *":
    return _c3.generic_function_lin_comb2(arg1, arg2, arg3, arg4, arg5)
generic_function_lin_comb2 = _c3.generic_function_lin_comb2

def generic_function_deriv(arg1: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_deriv(arg1)
generic_function_deriv = _c3.generic_function_deriv

def generic_function_dderiv(arg1: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_dderiv(arg1)
generic_function_dderiv = _c3.generic_function_dderiv

def generic_function_dderiv_periodic(arg1: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_dderiv_periodic(arg1)
generic_function_dderiv_periodic = _c3.generic_function_dderiv_periodic

def generic_function_create_nodal(arg1: 'GenericFunction', arg2: 'size_t', arg3: 'double *') -> "struct GenericFunction *":
    return _c3.generic_function_create_nodal(arg1, arg2, arg3)
generic_function_create_nodal = _c3.generic_function_create_nodal

def generic_function_sum_prod(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'size_t', arg5: 'struct GenericFunction **') -> "struct GenericFunction *":
    return _c3.generic_function_sum_prod(arg1, arg2, arg3, arg4, arg5)
generic_function_sum_prod = _c3.generic_function_sum_prod

def generic_function_prod(arg1: 'GenericFunction', arg2: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_prod(arg1, arg2)
generic_function_prod = _c3.generic_function_prod

def generic_function_daxpby(arg1: 'double', arg2: 'GenericFunction', arg3: 'double', arg4: 'GenericFunction') -> "struct GenericFunction *":
    return _c3.generic_function_daxpby(arg1, arg2, arg3, arg4)
generic_function_daxpby = _c3.generic_function_daxpby

def generic_function_array_daxpby(arg1: 'size_t', arg2: 'double', arg3: 'size_t', arg4: 'struct GenericFunction **', arg5: 'double', arg6: 'size_t', arg7: 'struct GenericFunction **') -> "struct GenericFunction **":
    return _c3.generic_function_array_daxpby(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
generic_function_array_daxpby = _c3.generic_function_array_daxpby

def generic_function_get_num_params(arg1: 'GenericFunction') -> "size_t":
    return _c3.generic_function_get_num_params(arg1)
generic_function_get_num_params = _c3.generic_function_get_num_params

def generic_function_get_lb(arg1: 'GenericFunction') -> "double":
    return _c3.generic_function_get_lb(arg1)
generic_function_get_lb = _c3.generic_function_get_lb

def generic_function_get_ub(arg1: 'GenericFunction') -> "double":
    return _c3.generic_function_get_ub(arg1)
generic_function_get_ub = _c3.generic_function_get_ub

def generic_function_get_fc(arg1: 'GenericFunction') -> "enum function_class":
    return _c3.generic_function_get_fc(arg1)
generic_function_get_fc = _c3.generic_function_get_fc

def generic_function_is_kristoffel_active(arg1: 'GenericFunction') -> "int":
    return _c3.generic_function_is_kristoffel_active(arg1)
generic_function_is_kristoffel_active = _c3.generic_function_is_kristoffel_active

def generic_function_activate_kristoffel(arg1: 'GenericFunction') -> "void":
    return _c3.generic_function_activate_kristoffel(arg1)
generic_function_activate_kristoffel = _c3.generic_function_activate_kristoffel

def generic_function_deactivate_kristoffel(arg1: 'GenericFunction') -> "void":
    return _c3.generic_function_deactivate_kristoffel(arg1)
generic_function_deactivate_kristoffel = _c3.generic_function_deactivate_kristoffel

def generic_function_get_kristoffel_weight(arg1: 'GenericFunction', arg2: 'double') -> "double":
    return _c3.generic_function_get_kristoffel_weight(arg1, arg2)
generic_function_get_kristoffel_weight = _c3.generic_function_get_kristoffel_weight

def generic_function_get_params(arg1: 'GenericFunction', arg2: 'double *') -> "size_t":
    return _c3.generic_function_get_params(arg1, arg2)
generic_function_get_params = _c3.generic_function_get_params

def generic_function_get_params_ref(arg1: 'GenericFunction', arg2: 'size_t *') -> "double *":
    return _c3.generic_function_get_params_ref(arg1, arg2)
generic_function_get_params_ref = _c3.generic_function_get_params_ref

def generic_function_update_params(arg1: 'GenericFunction', arg2: 'size_t', arg3: 'double const *') -> "int":
    return _c3.generic_function_update_params(arg1, arg2, arg3)
generic_function_update_params = _c3.generic_function_update_params

def generic_function_roundt(arg1: 'struct GenericFunction **', arg2: 'double') -> "void":
    return _c3.generic_function_roundt(arg1, arg2)
generic_function_roundt = _c3.generic_function_roundt

def generic_function_array_onezero(arg1: 'struct GenericFunction **', arg2: 'size_t', arg3: 'enum function_class', arg4: 'size_t', arg5: 'size_t *', arg6: 'double *', arg7: 'void *') -> "void":
    return _c3.generic_function_array_onezero(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
generic_function_array_onezero = _c3.generic_function_array_onezero

def generic_function_flip_sign(arg1: 'GenericFunction') -> "void":
    return _c3.generic_function_flip_sign(arg1)
generic_function_flip_sign = _c3.generic_function_flip_sign

def generic_function_array_flip_sign(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **') -> "void":
    return _c3.generic_function_array_flip_sign(arg1, arg2, arg3)
generic_function_array_flip_sign = _c3.generic_function_array_flip_sign

def generic_function_weighted_sum_pa(arg1: 'double', arg2: 'GenericFunction', arg3: 'double', arg4: 'GenericFunction', arg5: 'struct GenericFunction **') -> "void":
    return _c3.generic_function_weighted_sum_pa(arg1, arg2, arg3, arg4, arg5)
generic_function_weighted_sum_pa = _c3.generic_function_weighted_sum_pa

def generic_function_sum3_up(arg1: 'double', arg2: 'GenericFunction', arg3: 'double', arg4: 'GenericFunction', arg5: 'double', arg6: 'GenericFunction') -> "void":
    return _c3.generic_function_sum3_up(arg1, arg2, arg3, arg4, arg5, arg6)
generic_function_sum3_up = _c3.generic_function_sum3_up

def generic_function_axpy(arg1: 'double', arg2: 'GenericFunction', arg3: 'GenericFunction') -> "int":
    return _c3.generic_function_axpy(arg1, arg2, arg3)
generic_function_axpy = _c3.generic_function_axpy

def generic_function_array_axpy(arg1: 'size_t', arg2: 'double', arg3: 'struct GenericFunction **', arg4: 'struct GenericFunction **') -> "int":
    return _c3.generic_function_array_axpy(arg1, arg2, arg3, arg4)
generic_function_array_axpy = _c3.generic_function_array_axpy

def generic_function_scale(arg1: 'double', arg2: 'GenericFunction') -> "void":
    return _c3.generic_function_scale(arg1, arg2)
generic_function_scale = _c3.generic_function_scale

def generic_function_array_scale(arg1: 'double', arg2: 'struct GenericFunction **', arg3: 'size_t') -> "void":
    return _c3.generic_function_array_scale(arg1, arg2, arg3)
generic_function_array_scale = _c3.generic_function_array_scale

def generic_function_kronh(arg1: 'int', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t', arg6: 'double const *', arg7: 'struct GenericFunction **', arg8: 'struct GenericFunction **') -> "void":
    return _c3.generic_function_kronh(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
generic_function_kronh = _c3.generic_function_kronh

def generic_function_kronh2(arg1: 'int', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t', arg6: 'struct GenericFunction **', arg7: 'struct GenericFunction **', arg8: 'struct GenericFunction **') -> "void":
    return _c3.generic_function_kronh2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
generic_function_kronh2 = _c3.generic_function_kronh2

def generic_function_array_orth(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'enum function_class', arg4: 'void *') -> "void":
    return _c3.generic_function_array_orth(arg1, arg2, arg3, arg4)
generic_function_array_orth = _c3.generic_function_array_orth

def generic_function_array_daxpby2(arg1: 'size_t', arg2: 'double', arg3: 'size_t', arg4: 'struct GenericFunction **', arg5: 'double', arg6: 'size_t', arg7: 'struct GenericFunction **', arg8: 'size_t', arg9: 'struct GenericFunction **') -> "void":
    return _c3.generic_function_array_daxpby2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
generic_function_array_daxpby2 = _c3.generic_function_array_daxpby2

def generic_function_1d_eval(arg1: 'GenericFunction', arg2: 'double') -> "double":
    return _c3.generic_function_1d_eval(arg1, arg2)
generic_function_1d_eval = _c3.generic_function_1d_eval

def generic_function_deriv_eval(arg1: 'GenericFunction', arg2: 'double') -> "double":
    return _c3.generic_function_deriv_eval(arg1, arg2)
generic_function_deriv_eval = _c3.generic_function_deriv_eval

def generic_function_1d_evalN(arg1: 'GenericFunction', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t') -> "void":
    return _c3.generic_function_1d_evalN(arg1, arg2, arg3, arg4, arg5, arg6)
generic_function_1d_evalN = _c3.generic_function_1d_evalN

def generic_function_1d_eval_ind(arg1: 'GenericFunction', arg2: 'size_t') -> "double":
    return _c3.generic_function_1d_eval_ind(arg1, arg2)
generic_function_1d_eval_ind = _c3.generic_function_1d_eval_ind

def generic_function_1darray_eval(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'double') -> "double *":
    return _c3.generic_function_1darray_eval(arg1, arg2, arg3)
generic_function_1darray_eval = _c3.generic_function_1darray_eval

def generic_function_1darray_eval_piv(arg1: 'struct GenericFunction **', arg2: 'struct Pivot *') -> "double":
    return _c3.generic_function_1darray_eval_piv(arg1, arg2)
generic_function_1darray_eval_piv = _c3.generic_function_1darray_eval_piv

def generic_function_1darray_eval2(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'double', arg4: 'double *') -> "void":
    return _c3.generic_function_1darray_eval2(arg1, arg2, arg3, arg4)
generic_function_1darray_eval2 = _c3.generic_function_1darray_eval2

def generic_function_1darray_eval2N(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'size_t', arg4: 'double const *', arg5: 'size_t', arg6: 'double *', arg7: 'size_t') -> "void":
    return _c3.generic_function_1darray_eval2N(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
generic_function_1darray_eval2N = _c3.generic_function_1darray_eval2N

def generic_function_1darray_eval2_ind(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'size_t', arg4: 'double *') -> "void":
    return _c3.generic_function_1darray_eval2_ind(arg1, arg2, arg3, arg4)
generic_function_1darray_eval2_ind = _c3.generic_function_1darray_eval2_ind

def generic_function_param_grad_eval(arg1: 'GenericFunction', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "int":
    return _c3.generic_function_param_grad_eval(arg1, arg2, arg3, arg4)
generic_function_param_grad_eval = _c3.generic_function_param_grad_eval

def generic_function_param_grad_eval2(arg1: 'GenericFunction', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.generic_function_param_grad_eval2(arg1, arg2, arg3)
generic_function_param_grad_eval2 = _c3.generic_function_param_grad_eval2

def generic_function_integrate(arg1: 'GenericFunction') -> "double":
    return _c3.generic_function_integrate(arg1)
generic_function_integrate = _c3.generic_function_integrate

def generic_function_integrate_weighted(arg1: 'GenericFunction') -> "double":
    return _c3.generic_function_integrate_weighted(arg1)
generic_function_integrate_weighted = _c3.generic_function_integrate_weighted

def generic_function_norm(arg1: 'GenericFunction') -> "double":
    return _c3.generic_function_norm(arg1)
generic_function_norm = _c3.generic_function_norm

def generic_function_inner(arg1: 'GenericFunction', arg2: 'GenericFunction') -> "double":
    return _c3.generic_function_inner(arg1, arg2)
generic_function_inner = _c3.generic_function_inner

def generic_function_inner_weighted(arg1: 'GenericFunction', arg2: 'GenericFunction') -> "double":
    return _c3.generic_function_inner_weighted(arg1, arg2)
generic_function_inner_weighted = _c3.generic_function_inner_weighted

def generic_function_inner_sum(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'size_t', arg5: 'struct GenericFunction **') -> "double":
    return _c3.generic_function_inner_sum(arg1, arg2, arg3, arg4, arg5)
generic_function_inner_sum = _c3.generic_function_inner_sum

def generic_function_inner_weighted_sum(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'size_t', arg5: 'struct GenericFunction **') -> "double":
    return _c3.generic_function_inner_weighted_sum(arg1, arg2, arg3, arg4, arg5)
generic_function_inner_weighted_sum = _c3.generic_function_inner_weighted_sum

def generic_function_norm2diff(arg1: 'GenericFunction', arg2: 'GenericFunction') -> "double":
    return _c3.generic_function_norm2diff(arg1, arg2)
generic_function_norm2diff = _c3.generic_function_norm2diff

def generic_function_array_norm2diff(arg1: 'size_t', arg2: 'struct GenericFunction **', arg3: 'size_t', arg4: 'struct GenericFunction **', arg5: 'size_t') -> "double":
    return _c3.generic_function_array_norm2diff(arg1, arg2, arg3, arg4, arg5)
generic_function_array_norm2diff = _c3.generic_function_array_norm2diff

def generic_function_integral_array(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **') -> "double *":
    return _c3.generic_function_integral_array(arg1, arg2, arg3)
generic_function_integral_array = _c3.generic_function_integral_array

def generic_function_array_norm(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **') -> "double":
    return _c3.generic_function_array_norm(arg1, arg2, arg3)
generic_function_array_norm = _c3.generic_function_array_norm

def generic_function_absmax(arg1: 'GenericFunction', arg2: 'double *', arg3: 'void *') -> "double":
    return _c3.generic_function_absmax(arg1, arg2, arg3)
generic_function_absmax = _c3.generic_function_absmax

def generic_function_absmax_gen(arg1: 'GenericFunction', arg2: 'void *', arg3: 'size_t', arg4: 'void *') -> "double":
    return _c3.generic_function_absmax_gen(arg1, arg2, arg3, arg4)
generic_function_absmax_gen = _c3.generic_function_absmax_gen

def generic_function_array_absmax(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'size_t *', arg5: 'double *', arg6: 'void *') -> "double":
    return _c3.generic_function_array_absmax(arg1, arg2, arg3, arg4, arg5, arg6)
generic_function_array_absmax = _c3.generic_function_array_absmax

def generic_function_array_absmax_piv(arg1: 'size_t', arg2: 'size_t', arg3: 'struct GenericFunction **', arg4: 'struct Pivot *', arg5: 'void *') -> "double":
    return _c3.generic_function_array_absmax_piv(arg1, arg2, arg3, arg4, arg5)
generic_function_array_absmax_piv = _c3.generic_function_array_absmax_piv

def regress_1d_opts_create(arg1: 'enum approx_type', arg2: 'enum regress_type', arg3: 'size_t', arg4: 'double const *', arg5: 'double const *') -> "struct Regress1DOpts *":
    return _c3.regress_1d_opts_create(arg1, arg2, arg3, arg4, arg5)
regress_1d_opts_create = _c3.regress_1d_opts_create

def regress_1d_opts_destroy(arg1: 'struct Regress1DOpts *') -> "void":
    return _c3.regress_1d_opts_destroy(arg1)
regress_1d_opts_destroy = _c3.regress_1d_opts_destroy

def regress_1d_opts_set_parametric_form(arg1: 'struct Regress1DOpts *', arg2: 'enum function_class', arg3: 'void *') -> "void":
    return _c3.regress_1d_opts_set_parametric_form(arg1, arg2, arg3)
regress_1d_opts_set_parametric_form = _c3.regress_1d_opts_set_parametric_form

def regress_1d_opts_set_initial_parameters(arg1: 'struct Regress1DOpts *', arg2: 'double const *') -> "void":
    return _c3.regress_1d_opts_set_initial_parameters(arg1, arg2)
regress_1d_opts_set_initial_parameters = _c3.regress_1d_opts_set_initial_parameters

def generic_function_squared_norm_param_grad(arg1: 'GenericFunction', arg2: 'double', arg3: 'double *') -> "int":
    return _c3.generic_function_squared_norm_param_grad(arg1, arg2, arg3)
generic_function_squared_norm_param_grad = _c3.generic_function_squared_norm_param_grad

def regress_1d_opts_set_regularization_penalty(arg1: 'struct Regress1DOpts *', arg2: 'double') -> "void":
    return _c3.regress_1d_opts_set_regularization_penalty(arg1, arg2)
regress_1d_opts_set_regularization_penalty = _c3.regress_1d_opts_set_regularization_penalty

def regress_1d_opts_set_RKHS_decay_rate(arg1: 'struct Regress1DOpts *', arg2: 'enum coeff_decay_type', arg3: 'double') -> "void":
    return _c3.regress_1d_opts_set_RKHS_decay_rate(arg1, arg2, arg3)
regress_1d_opts_set_RKHS_decay_rate = _c3.regress_1d_opts_set_RKHS_decay_rate

def param_LSregress_cost(arg1: 'size_t', arg2: 'double const *', arg3: 'double *', arg4: 'void *') -> "double":
    return _c3.param_LSregress_cost(arg1, arg2, arg3, arg4)
param_LSregress_cost = _c3.param_LSregress_cost

def param_RLS2regress_cost(arg1: 'size_t', arg2: 'double const *', arg3: 'double *', arg4: 'void *') -> "double":
    return _c3.param_RLS2regress_cost(arg1, arg2, arg3, arg4)
param_RLS2regress_cost = _c3.param_RLS2regress_cost

def param_RLSD2regress_cost(arg1: 'size_t', arg2: 'double const *', arg3: 'double *', arg4: 'void *') -> "double":
    return _c3.param_RLSD2regress_cost(arg1, arg2, arg3, arg4)
param_RLSD2regress_cost = _c3.param_RLSD2regress_cost

def param_RLSRKHSregress_cost(arg1: 'size_t', arg2: 'double const *', arg3: 'double *', arg4: 'void *') -> "double":
    return _c3.param_RLSRKHSregress_cost(arg1, arg2, arg3, arg4)
param_RLSRKHSregress_cost = _c3.param_RLSRKHSregress_cost
class FiberCut(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FiberCut, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FiberCut, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fpoint"] = _c3.FiberCut_fpoint_set
    __swig_getmethods__["fpoint"] = _c3.FiberCut_fpoint_get
    if _newclass:
        fpoint = _swig_property(_c3.FiberCut_fpoint_get, _c3.FiberCut_fpoint_set)
    __swig_setmethods__["totdim"] = _c3.FiberCut_totdim_set
    __swig_getmethods__["totdim"] = _c3.FiberCut_totdim_get
    if _newclass:
        totdim = _swig_property(_c3.FiberCut_totdim_get, _c3.FiberCut_totdim_set)
    __swig_setmethods__["dimcut"] = _c3.FiberCut_dimcut_set
    __swig_getmethods__["dimcut"] = _c3.FiberCut_dimcut_get
    if _newclass:
        dimcut = _swig_property(_c3.FiberCut_dimcut_get, _c3.FiberCut_dimcut_set)
    __swig_setmethods__["ftype_flag"] = _c3.FiberCut_ftype_flag_set
    __swig_getmethods__["ftype_flag"] = _c3.FiberCut_ftype_flag_get
    if _newclass:
        ftype_flag = _swig_property(_c3.FiberCut_ftype_flag_get, _c3.FiberCut_ftype_flag_set)
    __swig_setmethods__["args"] = _c3.FiberCut_args_set
    __swig_getmethods__["args"] = _c3.FiberCut_args_get
    if _newclass:
        args = _swig_property(_c3.FiberCut_args_get, _c3.FiberCut_args_set)
    __swig_setmethods__["vals"] = _c3.FiberCut_vals_set
    __swig_getmethods__["vals"] = _c3.FiberCut_vals_get
    if _newclass:
        vals = _swig_property(_c3.FiberCut_vals_get, _c3.FiberCut_vals_set)

    def __init__(self):
        this = _c3.new_FiberCut()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_FiberCut
    __del__ = lambda self: None
FiberCut_swigregister = _c3.FiberCut_swigregister
FiberCut_swigregister(FiberCut)

class func_type(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, func_type, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, func_type, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fnd"] = _c3.func_type_fnd_set
    __swig_getmethods__["fnd"] = _c3.func_type_fnd_get
    if _newclass:
        fnd = _swig_property(_c3.func_type_fnd_get, _c3.func_type_fnd_set)
    __swig_setmethods__["f2d"] = _c3.func_type_f2d_set
    __swig_getmethods__["f2d"] = _c3.func_type_f2d_get
    if _newclass:
        f2d = _swig_property(_c3.func_type_f2d_get, _c3.func_type_f2d_set)

    def __init__(self):
        this = _c3.new_func_type()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_func_type
    __del__ = lambda self: None
func_type_swigregister = _c3.func_type_swigregister
func_type_swigregister(func_type)


def fiber_cut_init2d(f: 'double (*)(double,double,void *)', arg2: 'void *', arg3: 'size_t', arg4: 'double') -> "struct FiberCut *":
    return _c3.fiber_cut_init2d(f, arg2, arg3, arg4)
fiber_cut_init2d = _c3.fiber_cut_init2d

def fiber_cut_2darray(f: 'double (*)(double,double,void *)', arg2: 'void *', arg3: 'size_t', arg4: 'size_t', arg5: 'double const *') -> "struct FiberCut **":
    return _c3.fiber_cut_2darray(f, arg2, arg3, arg4, arg5)
fiber_cut_2darray = _c3.fiber_cut_2darray

def fiber_cut_ndarray(arg1: 'double (*)(double *,void *)', arg2: 'void *', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t', arg6: 'double **') -> "struct FiberCut **":
    return _c3.fiber_cut_ndarray(arg1, arg2, arg3, arg4, arg5, arg6)
fiber_cut_ndarray = _c3.fiber_cut_ndarray

def fiber_cut_free(arg1: 'FiberCut') -> "void":
    return _c3.fiber_cut_free(arg1)
fiber_cut_free = _c3.fiber_cut_free

def fiber_cut_array_free(arg1: 'size_t', arg2: 'struct FiberCut **') -> "void":
    return _c3.fiber_cut_array_free(arg1, arg2)
fiber_cut_array_free = _c3.fiber_cut_array_free

def fiber_cut_eval2d(arg1: 'double', arg2: 'void *') -> "double":
    return _c3.fiber_cut_eval2d(arg1, arg2)
fiber_cut_eval2d = _c3.fiber_cut_eval2d

def fiber_cut_eval(arg1: 'double', arg2: 'void *') -> "double":
    return _c3.fiber_cut_eval(arg1, arg2)
fiber_cut_eval = _c3.fiber_cut_eval

def fwrap_create(arg1: 'size_t', arg2: 'char const *') -> "struct Fwrap *":
    return _c3.fwrap_create(arg1, arg2)
fwrap_create = _c3.fwrap_create

def fwrap_get_type(arg1: 'struct Fwrap const *') -> "int":
    return _c3.fwrap_get_type(arg1)
fwrap_get_type = _c3.fwrap_get_type

def fwrap_set_f(arg1: 'struct Fwrap *', arg2: 'double (*)(double const *,void *)', arg3: 'void *') -> "void":
    return _c3.fwrap_set_f(arg1, arg2, arg3)
fwrap_set_f = _c3.fwrap_set_f

def fwrap_set_findex(arg1: 'struct Fwrap *', arg2: 'double (*)(size_t const *,void *)', arg3: 'void *') -> "void":
    return _c3.fwrap_set_findex(arg1, arg2, arg3)
fwrap_set_findex = _c3.fwrap_set_findex

def fwrap_set_fvec(arg1: 'struct Fwrap *', arg2: 'int (*)(size_t,double const *,double *,void *)', arg3: 'void *') -> "void":
    return _c3.fwrap_set_fvec(arg1, arg2, arg3)
fwrap_set_fvec = _c3.fwrap_set_fvec

def fwrap_set_mofvec(arg1: 'struct Fwrap *', arg2: 'int (*)(size_t,size_t,double const *,double *,void *)', arg3: 'void *') -> "void":
    return _c3.fwrap_set_mofvec(arg1, arg2, arg3)
fwrap_set_mofvec = _c3.fwrap_set_mofvec

def fwrap_set_which_eval(arg1: 'struct Fwrap *', arg2: 'size_t') -> "void":
    return _c3.fwrap_set_which_eval(arg1, arg2)
fwrap_set_which_eval = _c3.fwrap_set_which_eval

def fwrap_get_which_eval(arg1: 'struct Fwrap const *') -> "size_t":
    return _c3.fwrap_get_which_eval(arg1)
fwrap_get_which_eval = _c3.fwrap_get_which_eval

def fwrap_set_num_funcs(arg1: 'struct Fwrap *', arg2: 'size_t') -> "void":
    return _c3.fwrap_set_num_funcs(arg1, arg2)
fwrap_set_num_funcs = _c3.fwrap_set_num_funcs

def fwrap_set_func_array(arg1: 'struct Fwrap *', arg2: 'size_t', arg3: 'int (*)(size_t,double const *,double *,void *)', arg4: 'void *') -> "void":
    return _c3.fwrap_set_func_array(arg1, arg2, arg3, arg4)
fwrap_set_func_array = _c3.fwrap_set_func_array

def fwrap_destroy(arg1: 'struct Fwrap *') -> "void":
    return _c3.fwrap_destroy(arg1)
fwrap_destroy = _c3.fwrap_destroy

def fwrap_eval(arg1: 'size_t', arg2: 'void const *', arg3: 'double *', arg4: 'void *') -> "int":
    return _c3.fwrap_eval(arg1, arg2, arg3, arg4)
fwrap_eval = _c3.fwrap_eval

def fwrap_initialize_fiber_approx(arg1: 'struct Fwrap *', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.fwrap_initialize_fiber_approx(arg1, arg2, arg3)
fwrap_initialize_fiber_approx = _c3.fwrap_initialize_fiber_approx

def fwrap_add_fiber(arg1: 'struct Fwrap *', arg2: 'size_t', arg3: 'size_t', arg4: 'void const *', arg5: 'size_t', arg6: 'void const *') -> "void":
    return _c3.fwrap_add_fiber(arg1, arg2, arg3, arg4, arg5, arg6)
fwrap_add_fiber = _c3.fwrap_add_fiber

def fwrap_set_which_fiber(arg1: 'struct Fwrap *', arg2: 'size_t') -> "void":
    return _c3.fwrap_set_which_fiber(arg1, arg2)
fwrap_set_which_fiber = _c3.fwrap_set_which_fiber

def fwrap_clean_fiber_approx(arg1: 'struct Fwrap *') -> "void":
    return _c3.fwrap_clean_fiber_approx(arg1)
fwrap_clean_fiber_approx = _c3.fwrap_clean_fiber_approx

def fwrap_eval_fiber(arg1: 'size_t', arg2: 'void const *', arg3: 'double *', arg4: 'void *') -> "int":
    return _c3.fwrap_eval_fiber(arg1, arg2, arg3, arg4)
fwrap_eval_fiber = _c3.fwrap_eval_fiber
SQRTPIINV = _c3.SQRTPIINV

def init_hermite_poly() -> "struct OrthPoly *":
    return _c3.init_hermite_poly()
init_hermite_poly = _c3.init_hermite_poly

def hermite_integrate(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.hermite_integrate(arg1)
hermite_integrate = _c3.hermite_integrate
M_PI = _c3.M_PI

def lin_elem_exp_aopts_alloc_adapt(arg1: 'size_t', arg2: 'double *', arg3: 'double', arg4: 'double', arg5: 'double', arg6: 'double') -> "struct LinElemExpAopts *":
    return _c3.lin_elem_exp_aopts_alloc_adapt(arg1, arg2, arg3, arg4, arg5, arg6)
lin_elem_exp_aopts_alloc_adapt = _c3.lin_elem_exp_aopts_alloc_adapt

def lin_elem_exp_aopts_free(arg1: 'struct LinElemExpAopts *') -> "void":
    return _c3.lin_elem_exp_aopts_free(arg1)
lin_elem_exp_aopts_free = _c3.lin_elem_exp_aopts_free

def lin_elem_exp_aopts_free_deep(arg1: 'struct LinElemExpAopts **') -> "void":
    return _c3.lin_elem_exp_aopts_free_deep(arg1)
lin_elem_exp_aopts_free_deep = _c3.lin_elem_exp_aopts_free_deep

def lin_elem_exp_aopts_get_lb(arg1: 'struct LinElemExpAopts const *') -> "double":
    return _c3.lin_elem_exp_aopts_get_lb(arg1)
lin_elem_exp_aopts_get_lb = _c3.lin_elem_exp_aopts_get_lb

def lin_elem_exp_aopts_get_ub(arg1: 'struct LinElemExpAopts const *') -> "double":
    return _c3.lin_elem_exp_aopts_get_ub(arg1)
lin_elem_exp_aopts_get_ub = _c3.lin_elem_exp_aopts_get_ub

def lin_elem_exp_aopts_set_nodes(arg1: 'struct LinElemExpAopts *', arg2: 'size_t', arg3: 'double *') -> "void":
    return _c3.lin_elem_exp_aopts_set_nodes(arg1, arg2, arg3)
lin_elem_exp_aopts_set_nodes = _c3.lin_elem_exp_aopts_set_nodes

def lin_elem_exp_aopts_set_nodes_copy(arg1: 'struct LinElemExpAopts *', arg2: 'size_t', ydata: 'double const *') -> "void":
    return _c3.lin_elem_exp_aopts_set_nodes_copy(arg1, arg2, ydata)
lin_elem_exp_aopts_set_nodes_copy = _c3.lin_elem_exp_aopts_set_nodes_copy

def lin_elem_exp_aopts_set_adapt(arg1: 'struct LinElemExpAopts *', arg2: 'double', arg3: 'double') -> "void":
    return _c3.lin_elem_exp_aopts_set_adapt(arg1, arg2, arg3)
lin_elem_exp_aopts_set_adapt = _c3.lin_elem_exp_aopts_set_adapt

def lin_elem_exp_aopts_set_delta(arg1: 'struct LinElemExpAopts *', arg2: 'double') -> "void":
    return _c3.lin_elem_exp_aopts_set_delta(arg1, arg2)
lin_elem_exp_aopts_set_delta = _c3.lin_elem_exp_aopts_set_delta

def lin_elem_exp_aopts_set_hmin(arg1: 'struct LinElemExpAopts *', arg2: 'double') -> "void":
    return _c3.lin_elem_exp_aopts_set_hmin(arg1, arg2)
lin_elem_exp_aopts_set_hmin = _c3.lin_elem_exp_aopts_set_hmin

def lin_elem_exp_aopts_get_num_nodes(arg1: 'struct LinElemExpAopts const *') -> "size_t":
    return _c3.lin_elem_exp_aopts_get_num_nodes(arg1)
lin_elem_exp_aopts_get_num_nodes = _c3.lin_elem_exp_aopts_get_num_nodes

def lin_elem_exp_aopts_get_nparams(arg1: 'struct LinElemExpAopts const *') -> "size_t":
    return _c3.lin_elem_exp_aopts_get_nparams(arg1)
lin_elem_exp_aopts_get_nparams = _c3.lin_elem_exp_aopts_get_nparams

def lin_elem_exp_aopts_set_nparams(arg1: 'struct LinElemExpAopts *', arg2: 'size_t') -> "void":
    return _c3.lin_elem_exp_aopts_set_nparams(arg1, arg2)
lin_elem_exp_aopts_set_nparams = _c3.lin_elem_exp_aopts_set_nparams
class LinElemExp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinElemExp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinElemExp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["num_nodes"] = _c3.LinElemExp_num_nodes_set
    __swig_getmethods__["num_nodes"] = _c3.LinElemExp_num_nodes_get
    if _newclass:
        num_nodes = _swig_property(_c3.LinElemExp_num_nodes_get, _c3.LinElemExp_num_nodes_set)
    __swig_setmethods__["nodes"] = _c3.LinElemExp_nodes_set
    __swig_getmethods__["nodes"] = _c3.LinElemExp_nodes_get
    if _newclass:
        nodes = _swig_property(_c3.LinElemExp_nodes_get, _c3.LinElemExp_nodes_set)
    __swig_setmethods__["coeff"] = _c3.LinElemExp_coeff_set
    __swig_getmethods__["coeff"] = _c3.LinElemExp_coeff_get
    if _newclass:
        coeff = _swig_property(_c3.LinElemExp_coeff_get, _c3.LinElemExp_coeff_set)
    __swig_setmethods__["diff"] = _c3.LinElemExp_diff_set
    __swig_getmethods__["diff"] = _c3.LinElemExp_diff_get
    if _newclass:
        diff = _swig_property(_c3.LinElemExp_diff_get, _c3.LinElemExp_diff_set)
    __swig_setmethods__["inner"] = _c3.LinElemExp_inner_set
    __swig_getmethods__["inner"] = _c3.LinElemExp_inner_get
    if _newclass:
        inner = _swig_property(_c3.LinElemExp_inner_get, _c3.LinElemExp_inner_set)
    __swig_setmethods__["Lp"] = _c3.LinElemExp_Lp_set
    __swig_getmethods__["Lp"] = _c3.LinElemExp_Lp_get
    if _newclass:
        Lp = _swig_property(_c3.LinElemExp_Lp_get, _c3.LinElemExp_Lp_set)

    def __init__(self):
        this = _c3.new_LinElemExp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_LinElemExp
    __del__ = lambda self: None
LinElemExp_swigregister = _c3.LinElemExp_swigregister
LinElemExp_swigregister(LinElemExp)
cvar = _c3.cvar
lpolycoeffs = cvar.lpolycoeffs


def lin_elem_exp_get_num_nodes(arg1: 'LinElemExp') -> "size_t":
    return _c3.lin_elem_exp_get_num_nodes(arg1)
lin_elem_exp_get_num_nodes = _c3.lin_elem_exp_get_num_nodes

def lin_elem_exp_get_num_params(arg1: 'LinElemExp') -> "size_t":
    return _c3.lin_elem_exp_get_num_params(arg1)
lin_elem_exp_get_num_params = _c3.lin_elem_exp_get_num_params

def lin_elem_exp_alloc() -> "struct LinElemExp *":
    return _c3.lin_elem_exp_alloc()
lin_elem_exp_alloc = _c3.lin_elem_exp_alloc

def lin_elem_exp_copy(arg1: 'LinElemExp') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_copy(arg1)
lin_elem_exp_copy = _c3.lin_elem_exp_copy

def lin_elem_exp_free(arg1: 'LinElemExp') -> "void":
    return _c3.lin_elem_exp_free(arg1)
lin_elem_exp_free = _c3.lin_elem_exp_free

def lin_elem_exp_init(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_init(arg1, arg2, arg3)
lin_elem_exp_init = _c3.lin_elem_exp_init

def lin_elem_exp_create_with_params(arg1: 'struct LinElemExpAopts *', arg2: 'size_t', arg3: 'double const *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_create_with_params(arg1, arg2, arg3)
lin_elem_exp_create_with_params = _c3.lin_elem_exp_create_with_params

def lin_elem_exp_update_params(arg1: 'LinElemExp', arg2: 'size_t', arg3: 'double const *') -> "int":
    return _c3.lin_elem_exp_update_params(arg1, arg2, arg3)
lin_elem_exp_update_params = _c3.lin_elem_exp_update_params

def lin_elem_exp_get_params(arg1: 'LinElemExp', arg2: 'double *') -> "size_t":
    return _c3.lin_elem_exp_get_params(arg1, arg2)
lin_elem_exp_get_params = _c3.lin_elem_exp_get_params

def lin_elem_exp_get_params_ref(arg1: 'LinElemExp', arg2: 'size_t *') -> "double *":
    return _c3.lin_elem_exp_get_params_ref(arg1, arg2)
lin_elem_exp_get_params_ref = _c3.lin_elem_exp_get_params_ref

def serialize_lin_elem_exp(arg1: 'unsigned char *', arg2: 'LinElemExp', arg3: 'size_t *') -> "unsigned char *":
    return _c3.serialize_lin_elem_exp(arg1, arg2, arg3)
serialize_lin_elem_exp = _c3.serialize_lin_elem_exp

def deserialize_lin_elem_exp(arg1: 'unsigned char *', arg2: 'struct LinElemExp **') -> "unsigned char *":
    return _c3.deserialize_lin_elem_exp(arg1, arg2)
deserialize_lin_elem_exp = _c3.deserialize_lin_elem_exp

def lin_elem_exp_eval(arg1: 'LinElemExp', arg2: 'double') -> "double":
    return _c3.lin_elem_exp_eval(arg1, arg2)
lin_elem_exp_eval = _c3.lin_elem_exp_eval

def lin_elem_exp_deriv_eval(arg1: 'LinElemExp', arg2: 'double') -> "double":
    return _c3.lin_elem_exp_deriv_eval(arg1, arg2)
lin_elem_exp_deriv_eval = _c3.lin_elem_exp_deriv_eval

def lin_elem_exp_evalN(arg1: 'LinElemExp', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t') -> "void":
    return _c3.lin_elem_exp_evalN(arg1, arg2, arg3, arg4, arg5, arg6)
lin_elem_exp_evalN = _c3.lin_elem_exp_evalN

def lin_elem_exp_get_nodal_val(arg1: 'LinElemExp', arg2: 'size_t') -> "double":
    return _c3.lin_elem_exp_get_nodal_val(arg1, arg2)
lin_elem_exp_get_nodal_val = _c3.lin_elem_exp_get_nodal_val

def lin_elem_exp_deriv(arg1: 'LinElemExp') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_deriv(arg1)
lin_elem_exp_deriv = _c3.lin_elem_exp_deriv

def lin_elem_exp_dderiv(arg1: 'LinElemExp') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_dderiv(arg1)
lin_elem_exp_dderiv = _c3.lin_elem_exp_dderiv

def lin_elem_exp_dderiv_periodic(arg1: 'LinElemExp') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_dderiv_periodic(arg1)
lin_elem_exp_dderiv_periodic = _c3.lin_elem_exp_dderiv_periodic

def lin_elem_exp_param_grad_eval(arg1: 'LinElemExp', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "int":
    return _c3.lin_elem_exp_param_grad_eval(arg1, arg2, arg3, arg4)
lin_elem_exp_param_grad_eval = _c3.lin_elem_exp_param_grad_eval

def lin_elem_exp_param_grad_eval2(arg1: 'LinElemExp', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.lin_elem_exp_param_grad_eval2(arg1, arg2, arg3)
lin_elem_exp_param_grad_eval2 = _c3.lin_elem_exp_param_grad_eval2

def lin_elem_exp_squared_norm_param_grad(arg1: 'LinElemExp', arg2: 'double', arg3: 'double *') -> "int":
    return _c3.lin_elem_exp_squared_norm_param_grad(arg1, arg2, arg3)
lin_elem_exp_squared_norm_param_grad = _c3.lin_elem_exp_squared_norm_param_grad

def lin_elem_exp_integrate(arg1: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_integrate(arg1)
lin_elem_exp_integrate = _c3.lin_elem_exp_integrate

def lin_elem_exp_integrate_weighted(arg1: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_integrate_weighted(arg1)
lin_elem_exp_integrate_weighted = _c3.lin_elem_exp_integrate_weighted

def lin_elem_exp_inner(arg1: 'LinElemExp', arg2: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_inner(arg1, arg2)
lin_elem_exp_inner = _c3.lin_elem_exp_inner

def lin_elem_exp_axpy(arg1: 'double', arg2: 'LinElemExp', arg3: 'LinElemExp') -> "int":
    return _c3.lin_elem_exp_axpy(arg1, arg2, arg3)
lin_elem_exp_axpy = _c3.lin_elem_exp_axpy

def lin_elem_exp_prod(arg1: 'LinElemExp', arg2: 'LinElemExp') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_prod(arg1, arg2)
lin_elem_exp_prod = _c3.lin_elem_exp_prod

def lin_elem_exp_norm(arg1: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_norm(arg1)
lin_elem_exp_norm = _c3.lin_elem_exp_norm

def lin_elem_exp_max(arg1: 'LinElemExp', arg2: 'double *') -> "double":
    return _c3.lin_elem_exp_max(arg1, arg2)
lin_elem_exp_max = _c3.lin_elem_exp_max

def lin_elem_exp_min(arg1: 'LinElemExp', arg2: 'double *') -> "double":
    return _c3.lin_elem_exp_min(arg1, arg2)
lin_elem_exp_min = _c3.lin_elem_exp_min

def lin_elem_exp_absmax(arg1: 'LinElemExp', arg2: 'void *', arg3: 'size_t', arg4: 'void *') -> "double":
    return _c3.lin_elem_exp_absmax(arg1, arg2, arg3, arg4)
lin_elem_exp_absmax = _c3.lin_elem_exp_absmax

def lin_elem_exp_err_est(arg1: 'LinElemExp', arg2: 'double *', arg3: 'short', arg4: 'short') -> "double":
    return _c3.lin_elem_exp_err_est(arg1, arg2, arg3, arg4)
lin_elem_exp_err_est = _c3.lin_elem_exp_err_est

def lin_elem_adapt(arg1: 'struct Fwrap *', arg2: 'double', arg3: 'double', arg4: 'double', arg5: 'double', arg6: 'double', arg7: 'double', x: 'struct LinElemXY **') -> "void":
    return _c3.lin_elem_adapt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x)
lin_elem_adapt = _c3.lin_elem_adapt

def lin_elem_xy_get_x(arg1: 'struct LinElemXY *') -> "double":
    return _c3.lin_elem_xy_get_x(arg1)
lin_elem_xy_get_x = _c3.lin_elem_xy_get_x

def lin_elem_xy_get_y(arg1: 'struct LinElemXY *') -> "double":
    return _c3.lin_elem_xy_get_y(arg1)
lin_elem_xy_get_y = _c3.lin_elem_xy_get_y

def lin_elem_xy_next(arg1: 'struct LinElemXY *') -> "struct LinElemXY *":
    return _c3.lin_elem_xy_next(arg1)
lin_elem_xy_next = _c3.lin_elem_xy_next

def lin_elem_xy_free(arg1: 'struct LinElemXY *') -> "void":
    return _c3.lin_elem_xy_free(arg1)
lin_elem_xy_free = _c3.lin_elem_xy_free

def lin_elem_exp_approx(arg1: 'struct LinElemExpAopts *', arg2: 'struct Fwrap *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_approx(arg1, arg2)
lin_elem_exp_approx = _c3.lin_elem_exp_approx

def lin_elem_exp_scale(arg1: 'double', arg2: 'LinElemExp') -> "void":
    return _c3.lin_elem_exp_scale(arg1, arg2)
lin_elem_exp_scale = _c3.lin_elem_exp_scale

def lin_elem_exp_flip_sign(arg1: 'LinElemExp') -> "void":
    return _c3.lin_elem_exp_flip_sign(arg1)
lin_elem_exp_flip_sign = _c3.lin_elem_exp_flip_sign

def lin_elem_exp_orth_basis(arg1: 'size_t', arg2: 'struct LinElemExp **', arg3: 'struct LinElemExpAopts *') -> "void":
    return _c3.lin_elem_exp_orth_basis(arg1, arg2, arg3)
lin_elem_exp_orth_basis = _c3.lin_elem_exp_orth_basis

def lin_elem_exp_zero(arg1: 'struct LinElemExpAopts const *', arg2: 'int') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_zero(arg1, arg2)
lin_elem_exp_zero = _c3.lin_elem_exp_zero

def lin_elem_exp_constant(arg1: 'double', arg2: 'struct LinElemExpAopts const *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_constant(arg1, arg2)
lin_elem_exp_constant = _c3.lin_elem_exp_constant

def lin_elem_exp_linear(arg1: 'double', arg2: 'double', arg3: 'struct LinElemExpAopts const *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_linear(arg1, arg2, arg3)
lin_elem_exp_linear = _c3.lin_elem_exp_linear

def lin_elem_exp_linear_update(arg1: 'LinElemExp', arg2: 'double', arg3: 'double') -> "int":
    return _c3.lin_elem_exp_linear_update(arg1, arg2, arg3)
lin_elem_exp_linear_update = _c3.lin_elem_exp_linear_update

def lin_elem_exp_quadratic(arg1: 'double', arg2: 'double', arg3: 'struct LinElemExpAopts const *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_quadratic(arg1, arg2, arg3)
lin_elem_exp_quadratic = _c3.lin_elem_exp_quadratic

def lin_elem_exp_get_lb(arg1: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_get_lb(arg1)
lin_elem_exp_get_lb = _c3.lin_elem_exp_get_lb

def lin_elem_exp_get_ub(arg1: 'LinElemExp') -> "double":
    return _c3.lin_elem_exp_get_ub(arg1)
lin_elem_exp_get_ub = _c3.lin_elem_exp_get_ub

def lin_elem_exp_onezero(arg1: 'size_t', arg2: 'double *', arg3: 'struct LinElemExpAopts *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_onezero(arg1, arg2, arg3)
lin_elem_exp_onezero = _c3.lin_elem_exp_onezero

def print_lin_elem_exp(arg1: 'LinElemExp', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_lin_elem_exp(arg1, arg2, arg3, arg4)
print_lin_elem_exp = _c3.print_lin_elem_exp

def lin_elem_exp_savetxt(arg1: 'LinElemExp', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.lin_elem_exp_savetxt(arg1, arg2, arg3)
lin_elem_exp_savetxt = _c3.lin_elem_exp_savetxt

def lin_elem_exp_loadtxt(arg1: 'FILE *') -> "struct LinElemExp *":
    return _c3.lin_elem_exp_loadtxt(arg1)
lin_elem_exp_loadtxt = _c3.lin_elem_exp_loadtxt

def gauss_kernel_eval(arg1: 'double', arg2: 'double', arg3: 'double', arg4: 'double') -> "double":
    return _c3.gauss_kernel_eval(arg1, arg2, arg3, arg4)
gauss_kernel_eval = _c3.gauss_kernel_eval

def gauss_kernel_deriv(arg1: 'double', arg2: 'double', arg3: 'double', arg4: 'double') -> "double":
    return _c3.gauss_kernel_deriv(arg1, arg2, arg3, arg4)
gauss_kernel_deriv = _c3.gauss_kernel_deriv

def gauss_kernel_integrate(arg1: 'double', arg2: 'double', arg3: 'double', arg4: 'double', arg5: 'double') -> "double":
    return _c3.gauss_kernel_integrate(arg1, arg2, arg3, arg4, arg5)
gauss_kernel_integrate = _c3.gauss_kernel_integrate

def gauss_kernel_inner(arg1: 'double', arg2: 'double', arg3: 'double', arg4: 'double', arg5: 'double', arg6: 'double', arg7: 'double', arg8: 'double') -> "double":
    return _c3.gauss_kernel_inner(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
gauss_kernel_inner = _c3.gauss_kernel_inner

def kernel_gaussian(arg1: 'double', arg2: 'double', arg3: 'double') -> "struct Kernel *":
    return _c3.kernel_gaussian(arg1, arg2, arg3)
kernel_gaussian = _c3.kernel_gaussian

def kernel_free(arg1: 'struct Kernel *') -> "void":
    return _c3.kernel_free(arg1)
kernel_free = _c3.kernel_free

def kernel_approx_opts_free(arg1: 'struct KernelApproxOpts *') -> "void":
    return _c3.kernel_approx_opts_free(arg1)
kernel_approx_opts_free = _c3.kernel_approx_opts_free

def kernel_approx_opts_gauss(arg1: 'size_t', onedx: 'double *', arg3: 'double', arg4: 'double') -> "struct KernelApproxOpts *":
    return _c3.kernel_approx_opts_gauss(arg1, onedx, arg3, arg4)
kernel_approx_opts_gauss = _c3.kernel_approx_opts_gauss

def kernel_approx_opts_set_center_adapt(arg1: 'struct KernelApproxOpts *', arg2: 'int') -> "void":
    return _c3.kernel_approx_opts_set_center_adapt(arg1, arg2)
kernel_approx_opts_set_center_adapt = _c3.kernel_approx_opts_set_center_adapt

def kernel_approx_opts_linear_p(arg1: 'struct KernelApproxOpts const *') -> "int":
    return _c3.kernel_approx_opts_linear_p(arg1)
kernel_approx_opts_linear_p = _c3.kernel_approx_opts_linear_p

def kernel_approx_opts_get_nparams(arg1: 'struct KernelApproxOpts *') -> "size_t":
    return _c3.kernel_approx_opts_get_nparams(arg1)
kernel_approx_opts_get_nparams = _c3.kernel_approx_opts_get_nparams

def kernel_approx_opts_set_nparams(arg1: 'struct KernelApproxOpts *', arg2: 'size_t') -> "void":
    return _c3.kernel_approx_opts_set_nparams(arg1, arg2)
kernel_approx_opts_set_nparams = _c3.kernel_approx_opts_set_nparams

def kernel_approx_opts_set_lb(arg1: 'struct KernelApproxOpts *', arg2: 'double') -> "void":
    return _c3.kernel_approx_opts_set_lb(arg1, arg2)
kernel_approx_opts_set_lb = _c3.kernel_approx_opts_set_lb

def kernel_approx_opts_get_lb(arg1: 'struct KernelApproxOpts *') -> "double":
    return _c3.kernel_approx_opts_get_lb(arg1)
kernel_approx_opts_get_lb = _c3.kernel_approx_opts_get_lb

def kernel_approx_opts_set_ub(arg1: 'struct KernelApproxOpts *', arg2: 'double') -> "void":
    return _c3.kernel_approx_opts_set_ub(arg1, arg2)
kernel_approx_opts_set_ub = _c3.kernel_approx_opts_set_ub

def kernel_approx_opts_get_ub(arg1: 'struct KernelApproxOpts *') -> "double":
    return _c3.kernel_approx_opts_get_ub(arg1)
kernel_approx_opts_get_ub = _c3.kernel_approx_opts_get_ub

def kernel_expansion_alloc(arg1: 'size_t') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_alloc(arg1)
kernel_expansion_alloc = _c3.kernel_expansion_alloc

def kernel_expansion_get_lb(arg1: 'struct KernelExpansion const *') -> "double":
    return _c3.kernel_expansion_get_lb(arg1)
kernel_expansion_get_lb = _c3.kernel_expansion_get_lb

def kernel_expansion_get_ub(arg1: 'struct KernelExpansion const *') -> "double":
    return _c3.kernel_expansion_get_ub(arg1)
kernel_expansion_get_ub = _c3.kernel_expansion_get_ub

def serialize_kernel_expansion(arg1: 'unsigned char *', arg2: 'struct KernelExpansion *', arg3: 'size_t *') -> "unsigned char *":
    return _c3.serialize_kernel_expansion(arg1, arg2, arg3)
serialize_kernel_expansion = _c3.serialize_kernel_expansion

def deserialize_kernel_expansion(arg1: 'unsigned char *', arg2: 'struct KernelExpansion **') -> "unsigned char *":
    return _c3.deserialize_kernel_expansion(arg1, arg2)
deserialize_kernel_expansion = _c3.deserialize_kernel_expansion

def kernel_expansion_copy(arg1: 'struct KernelExpansion *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_copy(arg1)
kernel_expansion_copy = _c3.kernel_expansion_copy

def kernel_expansion_free(arg1: 'struct KernelExpansion *') -> "void":
    return _c3.kernel_expansion_free(arg1)
kernel_expansion_free = _c3.kernel_expansion_free

def kernel_expansion_set_bounds(arg1: 'struct KernelExpansion *', arg2: 'double', arg3: 'double') -> "void":
    return _c3.kernel_expansion_set_bounds(arg1, arg2, arg3)
kernel_expansion_set_bounds = _c3.kernel_expansion_set_bounds

def kernel_expansion_get_nkernels(arg1: 'struct KernelExpansion const *') -> "size_t":
    return _c3.kernel_expansion_get_nkernels(arg1)
kernel_expansion_get_nkernels = _c3.kernel_expansion_get_nkernels

def kernel_expansion_add_kernel(arg1: 'struct KernelExpansion *', arg2: 'double', arg3: 'struct Kernel *') -> "void":
    return _c3.kernel_expansion_add_kernel(arg1, arg2, arg3)
kernel_expansion_add_kernel = _c3.kernel_expansion_add_kernel

def kernel_expansion_init(arg1: 'struct KernelApproxOpts const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_init(arg1)
kernel_expansion_init = _c3.kernel_expansion_init

def kernel_expansion_update_params(arg1: 'struct KernelExpansion *', arg2: 'size_t', arg3: 'double const *') -> "int":
    return _c3.kernel_expansion_update_params(arg1, arg2, arg3)
kernel_expansion_update_params = _c3.kernel_expansion_update_params

def kernel_expansion_create_with_params(arg1: 'struct KernelApproxOpts *', arg2: 'size_t', arg3: 'double const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_create_with_params(arg1, arg2, arg3)
kernel_expansion_create_with_params = _c3.kernel_expansion_create_with_params

def kernel_expansion_zero(arg1: 'struct KernelApproxOpts const *', arg2: 'int') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_zero(arg1, arg2)
kernel_expansion_zero = _c3.kernel_expansion_zero

def kernel_expansion_constant(val: 'double', arg2: 'struct KernelApproxOpts const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_constant(val, arg2)
kernel_expansion_constant = _c3.kernel_expansion_constant

def kernel_expansion_linear(arg1: 'double', arg2: 'double', arg3: 'struct KernelApproxOpts const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_linear(arg1, arg2, arg3)
kernel_expansion_linear = _c3.kernel_expansion_linear

def kernel_expansion_linear_update(arg1: 'struct KernelExpansion *', arg2: 'double', arg3: 'double') -> "int":
    return _c3.kernel_expansion_linear_update(arg1, arg2, arg3)
kernel_expansion_linear_update = _c3.kernel_expansion_linear_update

def kernel_expansion_quadratic(arg1: 'double', arg2: 'double', arg3: 'void *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_quadratic(arg1, arg2, arg3)
kernel_expansion_quadratic = _c3.kernel_expansion_quadratic

def kernel_expansion_eval(arg1: 'struct KernelExpansion const *', arg2: 'double') -> "double":
    return _c3.kernel_expansion_eval(arg1, arg2)
kernel_expansion_eval = _c3.kernel_expansion_eval

def kernel_expansion_evalN(arg1: 'struct KernelExpansion const *', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t') -> "void":
    return _c3.kernel_expansion_evalN(arg1, arg2, arg3, arg4, arg5, arg6)
kernel_expansion_evalN = _c3.kernel_expansion_evalN

def kernel_expansion_deriv(arg1: 'struct KernelExpansion const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_deriv(arg1)
kernel_expansion_deriv = _c3.kernel_expansion_deriv

def kernel_expansion_dderiv(arg1: 'struct KernelExpansion const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_dderiv(arg1)
kernel_expansion_dderiv = _c3.kernel_expansion_dderiv

def kernel_expansion_dderiv_periodic(arg1: 'struct KernelExpansion const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_dderiv_periodic(arg1)
kernel_expansion_dderiv_periodic = _c3.kernel_expansion_dderiv_periodic

def kernel_expansion_deriv_eval(arg1: 'struct KernelExpansion const *', arg2: 'double') -> "double":
    return _c3.kernel_expansion_deriv_eval(arg1, arg2)
kernel_expansion_deriv_eval = _c3.kernel_expansion_deriv_eval

def kernel_expansion_axpy(arg1: 'double', arg2: 'struct KernelExpansion *', arg3: 'struct KernelExpansion *') -> "int":
    return _c3.kernel_expansion_axpy(arg1, arg2, arg3)
kernel_expansion_axpy = _c3.kernel_expansion_axpy

def kernel_expansion_integrate(arg1: 'struct KernelExpansion *') -> "double":
    return _c3.kernel_expansion_integrate(arg1)
kernel_expansion_integrate = _c3.kernel_expansion_integrate

def kernel_expansion_integrate_weighted(arg1: 'struct KernelExpansion *') -> "double":
    return _c3.kernel_expansion_integrate_weighted(arg1)
kernel_expansion_integrate_weighted = _c3.kernel_expansion_integrate_weighted

def kernel_expansion_prod(arg1: 'struct KernelExpansion const *', arg2: 'struct KernelExpansion const *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_prod(arg1, arg2)
kernel_expansion_prod = _c3.kernel_expansion_prod

def kernel_expansion_inner(arg1: 'struct KernelExpansion *', arg2: 'struct KernelExpansion *') -> "double":
    return _c3.kernel_expansion_inner(arg1, arg2)
kernel_expansion_inner = _c3.kernel_expansion_inner

def kernel_expansion_scale(arg1: 'double', arg2: 'struct KernelExpansion *') -> "void":
    return _c3.kernel_expansion_scale(arg1, arg2)
kernel_expansion_scale = _c3.kernel_expansion_scale

def kernel_expansion_flip_sign(arg1: 'struct KernelExpansion *') -> "void":
    return _c3.kernel_expansion_flip_sign(arg1)
kernel_expansion_flip_sign = _c3.kernel_expansion_flip_sign

def kernel_expansion_get_num_params(arg1: 'struct KernelExpansion const *') -> "size_t":
    return _c3.kernel_expansion_get_num_params(arg1)
kernel_expansion_get_num_params = _c3.kernel_expansion_get_num_params

def kernel_expansion_get_params(arg1: 'struct KernelExpansion const *', arg2: 'double *') -> "size_t":
    return _c3.kernel_expansion_get_params(arg1, arg2)
kernel_expansion_get_params = _c3.kernel_expansion_get_params

def kernel_expansion_get_params_ref(arg1: 'struct KernelExpansion const *', arg2: 'size_t *') -> "double *":
    return _c3.kernel_expansion_get_params_ref(arg1, arg2)
kernel_expansion_get_params_ref = _c3.kernel_expansion_get_params_ref

def kernel_expansion_orth_basis(arg1: 'size_t', arg2: 'struct KernelExpansion **', arg3: 'struct KernelApproxOpts *') -> "void":
    return _c3.kernel_expansion_orth_basis(arg1, arg2, arg3)
kernel_expansion_orth_basis = _c3.kernel_expansion_orth_basis

def kernel_expansion_param_grad_eval(arg1: 'struct KernelExpansion *', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "int":
    return _c3.kernel_expansion_param_grad_eval(arg1, arg2, arg3, arg4)
kernel_expansion_param_grad_eval = _c3.kernel_expansion_param_grad_eval

def kernel_expansion_param_grad_eval2(arg1: 'struct KernelExpansion *', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.kernel_expansion_param_grad_eval2(arg1, arg2, arg3)
kernel_expansion_param_grad_eval2 = _c3.kernel_expansion_param_grad_eval2

def kernel_expansion_squared_norm_param_grad(arg1: 'struct KernelExpansion const *', arg2: 'double', arg3: 'double *') -> "int":
    return _c3.kernel_expansion_squared_norm_param_grad(arg1, arg2, arg3)
kernel_expansion_squared_norm_param_grad = _c3.kernel_expansion_squared_norm_param_grad

def print_kernel_expansion(arg1: 'struct KernelExpansion *', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_kernel_expansion(arg1, arg2, arg3, arg4)
print_kernel_expansion = _c3.print_kernel_expansion

def kernel_expansion_absmax(arg1: 'struct KernelExpansion const *', arg2: 'double *', arg3: 'void *') -> "double":
    return _c3.kernel_expansion_absmax(arg1, arg2, arg3)
kernel_expansion_absmax = _c3.kernel_expansion_absmax

def kernel_expansion_savetxt(arg1: 'struct KernelExpansion const *', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.kernel_expansion_savetxt(arg1, arg2, arg3)
kernel_expansion_savetxt = _c3.kernel_expansion_savetxt

def kernel_expansion_loadtxt(arg1: 'FILE *') -> "struct KernelExpansion *":
    return _c3.kernel_expansion_loadtxt(arg1)
kernel_expansion_loadtxt = _c3.kernel_expansion_loadtxt
class FunctionMonitor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FunctionMonitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FunctionMonitor, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _c3.FunctionMonitor_f_set
    __swig_getmethods__["f"] = _c3.FunctionMonitor_f_get
    if _newclass:
        f = _swig_property(_c3.FunctionMonitor_f_get, _c3.FunctionMonitor_f_set)
    __swig_setmethods__["ftype"] = _c3.FunctionMonitor_ftype_set
    __swig_getmethods__["ftype"] = _c3.FunctionMonitor_ftype_get
    if _newclass:
        ftype = _swig_property(_c3.FunctionMonitor_ftype_get, _c3.FunctionMonitor_ftype_set)
    __swig_setmethods__["dim"] = _c3.FunctionMonitor_dim_set
    __swig_getmethods__["dim"] = _c3.FunctionMonitor_dim_get
    if _newclass:
        dim = _swig_property(_c3.FunctionMonitor_dim_get, _c3.FunctionMonitor_dim_set)
    __swig_setmethods__["args"] = _c3.FunctionMonitor_args_set
    __swig_getmethods__["args"] = _c3.FunctionMonitor_args_get
    if _newclass:
        args = _swig_property(_c3.FunctionMonitor_args_get, _c3.FunctionMonitor_args_set)
    __swig_setmethods__["evals"] = _c3.FunctionMonitor_evals_set
    __swig_getmethods__["evals"] = _c3.FunctionMonitor_evals_get
    if _newclass:
        evals = _swig_property(_c3.FunctionMonitor_evals_get, _c3.FunctionMonitor_evals_set)

    def __init__(self):
        this = _c3.new_FunctionMonitor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_FunctionMonitor
    __del__ = lambda self: None
FunctionMonitor_swigregister = _c3.FunctionMonitor_swigregister
FunctionMonitor_swigregister(FunctionMonitor)

class ff(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ff, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ff, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fnd"] = _c3.ff_fnd_set
    __swig_getmethods__["fnd"] = _c3.ff_fnd_get
    if _newclass:
        fnd = _swig_property(_c3.ff_fnd_get, _c3.ff_fnd_set)
    __swig_setmethods__["f1d"] = _c3.ff_f1d_set
    __swig_getmethods__["f1d"] = _c3.ff_f1d_get
    if _newclass:
        f1d = _swig_property(_c3.ff_f1d_get, _c3.ff_f1d_set)
    __swig_setmethods__["f2d"] = _c3.ff_f2d_set
    __swig_getmethods__["f2d"] = _c3.ff_f2d_get
    if _newclass:
        f2d = _swig_property(_c3.ff_f2d_get, _c3.ff_f2d_set)

    def __init__(self):
        this = _c3.new_ff()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_ff
    __del__ = lambda self: None
ff_swigregister = _c3.ff_swigregister
ff_swigregister(ff)


def function_monitor_initnd(arg1: 'double (*)(double const *,void *)', arg2: 'void *', arg3: 'size_t', arg4: 'size_t') -> "struct FunctionMonitor *":
    return _c3.function_monitor_initnd(arg1, arg2, arg3, arg4)
function_monitor_initnd = _c3.function_monitor_initnd

def function_monitor_free(arg1: 'FunctionMonitor') -> "void":
    return _c3.function_monitor_free(arg1)
function_monitor_free = _c3.function_monitor_free

def function_monitor_eval(arg1: 'double const *', arg2: 'void *') -> "double":
    return _c3.function_monitor_eval(arg1, arg2)
function_monitor_eval = _c3.function_monitor_eval

def function_monitor_print_to_file(arg1: 'FunctionMonitor', arg2: 'FILE *') -> "void":
    return _c3.function_monitor_print_to_file(arg1, arg2)
function_monitor_print_to_file = _c3.function_monitor_print_to_file
class storevals_main(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, storevals_main, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, storevals_main, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nEvals"] = _c3.storevals_main_nEvals_set
    __swig_getmethods__["nEvals"] = _c3.storevals_main_nEvals_get
    if _newclass:
        nEvals = _swig_property(_c3.storevals_main_nEvals_get, _c3.storevals_main_nEvals_set)
    __swig_setmethods__["head"] = _c3.storevals_main_head_set
    __swig_getmethods__["head"] = _c3.storevals_main_head_get
    if _newclass:
        head = _swig_property(_c3.storevals_main_head_get, _c3.storevals_main_head_set)

    def __init__(self):
        this = _c3.new_storevals_main()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_storevals_main
    __del__ = lambda self: None
storevals_main_swigregister = _c3.storevals_main_swigregister
storevals_main_swigregister(storevals_main)

class storevals(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, storevals, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, storevals, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dim"] = _c3.storevals_dim_set
    __swig_getmethods__["dim"] = _c3.storevals_dim_get
    if _newclass:
        dim = _swig_property(_c3.storevals_dim_get, _c3.storevals_dim_set)
    __swig_setmethods__["x"] = _c3.storevals_x_set
    __swig_getmethods__["x"] = _c3.storevals_x_get
    if _newclass:
        x = _swig_property(_c3.storevals_x_get, _c3.storevals_x_set)
    __swig_setmethods__["f"] = _c3.storevals_f_set
    __swig_getmethods__["f"] = _c3.storevals_f_get
    if _newclass:
        f = _swig_property(_c3.storevals_f_get, _c3.storevals_f_set)
    __swig_setmethods__["next"] = _c3.storevals_next_set
    __swig_getmethods__["next"] = _c3.storevals_next_get
    if _newclass:
        next = _swig_property(_c3.storevals_next_get, _c3.storevals_next_set)

    def __init__(self):
        this = _c3.new_storevals()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_storevals
    __del__ = lambda self: None
storevals_swigregister = _c3.storevals_swigregister
storevals_swigregister(storevals)


def PushVal(arg1: 'struct storevals **', arg2: 'size_t', arg3: 'double *', arg4: 'double') -> "void":
    return _c3.PushVal(arg1, arg2, arg3, arg4)
PushVal = _c3.PushVal

def PrintVals2d(arg1: 'FILE *', arg2: 'storevals') -> "void":
    return _c3.PrintVals2d(arg1, arg2)
PrintVals2d = _c3.PrintVals2d

def DeleteStoredVals(arg1: 'struct storevals **') -> "void":
    return _c3.DeleteStoredVals(arg1)
DeleteStoredVals = _c3.DeleteStoredVals
class Cpair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cpair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cpair, name)
    __repr__ = _swig_repr
    __swig_setmethods__["a"] = _c3.Cpair_a_set
    __swig_getmethods__["a"] = _c3.Cpair_a_get
    if _newclass:
        a = _swig_property(_c3.Cpair_a_get, _c3.Cpair_a_set)
    __swig_setmethods__["b"] = _c3.Cpair_b_set
    __swig_getmethods__["b"] = _c3.Cpair_b_get
    if _newclass:
        b = _swig_property(_c3.Cpair_b_get, _c3.Cpair_b_set)

    def __init__(self):
        this = _c3.new_Cpair()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_Cpair
    __del__ = lambda self: None
Cpair_swigregister = _c3.Cpair_swigregister
Cpair_swigregister(Cpair)


def cpair_create(arg1: 'char *', arg2: 'char *') -> "struct Cpair *":
    return _c3.cpair_create(arg1, arg2)
cpair_create = _c3.cpair_create

def copy_cpair(arg1: 'Cpair') -> "struct Cpair *":
    return _c3.copy_cpair(arg1)
copy_cpair = _c3.copy_cpair

def print_cpair(arg1: 'Cpair') -> "void":
    return _c3.print_cpair(arg1)
print_cpair = _c3.print_cpair

def cpair_free(arg1: 'Cpair') -> "void":
    return _c3.cpair_free(arg1)
cpair_free = _c3.cpair_free

def cpair_isequal(arg1: 'Cpair', arg2: 'Cpair') -> "int":
    return _c3.cpair_isequal(arg1, arg2)
cpair_isequal = _c3.cpair_isequal
class PairList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PairList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _c3.PairList_data_set
    __swig_getmethods__["data"] = _c3.PairList_data_get
    if _newclass:
        data = _swig_property(_c3.PairList_data_get, _c3.PairList_data_set)
    __swig_setmethods__["next"] = _c3.PairList_next_set
    __swig_getmethods__["next"] = _c3.PairList_next_get
    if _newclass:
        next = _swig_property(_c3.PairList_next_get, _c3.PairList_next_set)

    def __init__(self):
        this = _c3.new_PairList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_PairList
    __del__ = lambda self: None
PairList_swigregister = _c3.PairList_swigregister
PairList_swigregister(PairList)


def pair_push(arg1: 'struct PairList **', arg2: 'Cpair') -> "void":
    return _c3.pair_push(arg1, arg2)
pair_push = _c3.pair_push

def print_pair_list(arg1: 'PairList') -> "void":
    return _c3.print_pair_list(arg1)
print_pair_list = _c3.print_pair_list

def pair_list_delete(arg1: 'struct PairList **') -> "void":
    return _c3.pair_list_delete(arg1)
pair_list_delete = _c3.pair_list_delete

def pair_list_len(arg1: 'PairList') -> "size_t":
    return _c3.pair_list_len(arg1)
pair_list_len = _c3.pair_list_len

def pair_list_index(arg1: 'PairList', arg2: 'Cpair') -> "size_t":
    return _c3.pair_list_index(arg1, arg2)
pair_list_index = _c3.pair_list_index
class HashtableCpair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HashtableCpair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HashtableCpair, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _c3.HashtableCpair_size_set
    __swig_getmethods__["size"] = _c3.HashtableCpair_size_get
    if _newclass:
        size = _swig_property(_c3.HashtableCpair_size_get, _c3.HashtableCpair_size_set)
    __swig_setmethods__["table"] = _c3.HashtableCpair_table_set
    __swig_getmethods__["table"] = _c3.HashtableCpair_table_get
    if _newclass:
        table = _swig_property(_c3.HashtableCpair_table_get, _c3.HashtableCpair_table_set)

    def __init__(self):
        this = _c3.new_HashtableCpair()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_HashtableCpair
    __del__ = lambda self: None
HashtableCpair_swigregister = _c3.HashtableCpair_swigregister
HashtableCpair_swigregister(HashtableCpair)


def create_hashtable_cp(arg1: 'size_t') -> "struct HashtableCpair *":
    return _c3.create_hashtable_cp(arg1)
create_hashtable_cp = _c3.create_hashtable_cp

def lookup_key(arg1: 'HashtableCpair', arg2: 'char *') -> "char *":
    return _c3.lookup_key(arg1, arg2)
lookup_key = _c3.lookup_key

def add_cpair(arg1: 'HashtableCpair', arg2: 'Cpair') -> "int":
    return _c3.add_cpair(arg1, arg2)
add_cpair = _c3.add_cpair

def free_hashtable_cp(arg1: 'HashtableCpair') -> "void":
    return _c3.free_hashtable_cp(arg1)
free_hashtable_cp = _c3.free_hashtable_cp

def nstored_hashtable_cp(arg1: 'HashtableCpair') -> "size_t":
    return _c3.nstored_hashtable_cp(arg1)
nstored_hashtable_cp = _c3.nstored_hashtable_cp

def hashsimple(arg1: 'size_t', arg2: 'char *') -> "size_t":
    return _c3.hashsimple(arg1, arg2)
hashsimple = _c3.hashsimple

def pw_poly_opts_alloc(arg1: 'enum poly_type', arg2: 'double', arg3: 'double') -> "struct PwPolyOpts *":
    return _c3.pw_poly_opts_alloc(arg1, arg2, arg3)
pw_poly_opts_alloc = _c3.pw_poly_opts_alloc

def pw_poly_opts_free(arg1: 'struct PwPolyOpts *') -> "void":
    return _c3.pw_poly_opts_free(arg1)
pw_poly_opts_free = _c3.pw_poly_opts_free

def pw_poly_opts_free_deep(arg1: 'struct PwPolyOpts **') -> "void":
    return _c3.pw_poly_opts_free_deep(arg1)
pw_poly_opts_free_deep = _c3.pw_poly_opts_free_deep

def pw_poly_opts_set_lb(arg1: 'struct PwPolyOpts *', arg2: 'double') -> "void":
    return _c3.pw_poly_opts_set_lb(arg1, arg2)
pw_poly_opts_set_lb = _c3.pw_poly_opts_set_lb

def pw_poly_opts_get_lb(arg1: 'struct PwPolyOpts const *') -> "double":
    return _c3.pw_poly_opts_get_lb(arg1)
pw_poly_opts_get_lb = _c3.pw_poly_opts_get_lb

def pw_poly_opts_set_ub(arg1: 'struct PwPolyOpts *', arg2: 'double') -> "void":
    return _c3.pw_poly_opts_set_ub(arg1, arg2)
pw_poly_opts_set_ub = _c3.pw_poly_opts_set_ub

def pw_poly_opts_get_ub(arg1: 'struct PwPolyOpts const *') -> "double":
    return _c3.pw_poly_opts_get_ub(arg1)
pw_poly_opts_get_ub = _c3.pw_poly_opts_get_ub

def pw_poly_opts_set_ptype(arg1: 'struct PwPolyOpts *', arg2: 'enum poly_type') -> "void":
    return _c3.pw_poly_opts_set_ptype(arg1, arg2)
pw_poly_opts_set_ptype = _c3.pw_poly_opts_set_ptype

def pw_poly_opts_get_ptype(arg1: 'struct PwPolyOpts const *') -> "enum poly_type":
    return _c3.pw_poly_opts_get_ptype(arg1)
pw_poly_opts_get_ptype = _c3.pw_poly_opts_get_ptype

def pw_poly_opts_set_minsize(arg1: 'struct PwPolyOpts *', arg2: 'double') -> "void":
    return _c3.pw_poly_opts_set_minsize(arg1, arg2)
pw_poly_opts_set_minsize = _c3.pw_poly_opts_set_minsize

def pw_poly_opts_set_maxorder(arg1: 'struct PwPolyOpts *', arg2: 'size_t') -> "void":
    return _c3.pw_poly_opts_set_maxorder(arg1, arg2)
pw_poly_opts_set_maxorder = _c3.pw_poly_opts_set_maxorder

def pw_poly_opts_set_nregions(arg1: 'struct PwPolyOpts *', arg2: 'size_t') -> "void":
    return _c3.pw_poly_opts_set_nregions(arg1, arg2)
pw_poly_opts_set_nregions = _c3.pw_poly_opts_set_nregions

def pw_poly_opts_set_pts(arg1: 'struct PwPolyOpts *', arg2: 'size_t', arg3: 'double *') -> "void":
    return _c3.pw_poly_opts_set_pts(arg1, arg2, arg3)
pw_poly_opts_set_pts = _c3.pw_poly_opts_set_pts

def pw_poly_opts_set_tol(arg1: 'struct PwPolyOpts *', arg2: 'double') -> "void":
    return _c3.pw_poly_opts_set_tol(arg1, arg2)
pw_poly_opts_set_tol = _c3.pw_poly_opts_set_tol

def pw_poly_opts_set_coeffs_check(arg1: 'struct PwPolyOpts *', arg2: 'size_t') -> "void":
    return _c3.pw_poly_opts_set_coeffs_check(arg1, arg2)
pw_poly_opts_set_coeffs_check = _c3.pw_poly_opts_set_coeffs_check

def pw_poly_opts_get_nparams(arg1: 'struct PwPolyOpts const *') -> "size_t":
    return _c3.pw_poly_opts_get_nparams(arg1)
pw_poly_opts_get_nparams = _c3.pw_poly_opts_get_nparams

def pw_poly_opts_set_nparams(arg1: 'struct PwPolyOpts *', arg2: 'size_t') -> "void":
    return _c3.pw_poly_opts_set_nparams(arg1, arg2)
pw_poly_opts_set_nparams = _c3.pw_poly_opts_set_nparams
class PiecewisePoly(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PiecewisePoly, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PiecewisePoly, name)
    __repr__ = _swig_repr
    __swig_setmethods__["leaf"] = _c3.PiecewisePoly_leaf_set
    __swig_getmethods__["leaf"] = _c3.PiecewisePoly_leaf_get
    if _newclass:
        leaf = _swig_property(_c3.PiecewisePoly_leaf_get, _c3.PiecewisePoly_leaf_set)
    __swig_setmethods__["nbranches"] = _c3.PiecewisePoly_nbranches_set
    __swig_getmethods__["nbranches"] = _c3.PiecewisePoly_nbranches_get
    if _newclass:
        nbranches = _swig_property(_c3.PiecewisePoly_nbranches_get, _c3.PiecewisePoly_nbranches_set)
    __swig_setmethods__["branches"] = _c3.PiecewisePoly_branches_set
    __swig_getmethods__["branches"] = _c3.PiecewisePoly_branches_get
    if _newclass:
        branches = _swig_property(_c3.PiecewisePoly_branches_get, _c3.PiecewisePoly_branches_set)
    __swig_setmethods__["ope"] = _c3.PiecewisePoly_ope_set
    __swig_getmethods__["ope"] = _c3.PiecewisePoly_ope_get
    if _newclass:
        ope = _swig_property(_c3.PiecewisePoly_ope_get, _c3.PiecewisePoly_ope_set)

    def __init__(self):
        this = _c3.new_PiecewisePoly()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_PiecewisePoly
    __del__ = lambda self: None
PiecewisePoly_swigregister = _c3.PiecewisePoly_swigregister
PiecewisePoly_swigregister(PiecewisePoly)


def piecewise_poly_alloc() -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_alloc()
piecewise_poly_alloc = _c3.piecewise_poly_alloc

def piecewise_poly_array_alloc(arg1: 'size_t') -> "struct PiecewisePoly **":
    return _c3.piecewise_poly_array_alloc(arg1)
piecewise_poly_array_alloc = _c3.piecewise_poly_array_alloc

def piecewise_poly_copy(arg1: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_copy(arg1)
piecewise_poly_copy = _c3.piecewise_poly_copy

def piecewise_poly_free(arg1: 'PiecewisePoly') -> "void":
    return _c3.piecewise_poly_free(arg1)
piecewise_poly_free = _c3.piecewise_poly_free

def piecewise_poly_array_free(arg1: 'struct PiecewisePoly **', arg2: 'size_t') -> "void":
    return _c3.piecewise_poly_array_free(arg1, arg2)
piecewise_poly_array_free = _c3.piecewise_poly_array_free

def piecewise_poly_get_ptype(p: 'PiecewisePoly') -> "enum poly_type":
    return _c3.piecewise_poly_get_ptype(p)
piecewise_poly_get_ptype = _c3.piecewise_poly_get_ptype

def piecewise_poly_genorder(arg1: 'size_t', arg2: 'struct PwPolyOpts *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_genorder(arg1, arg2)
piecewise_poly_genorder = _c3.piecewise_poly_genorder

def piecewise_poly_constant(arg1: 'double', arg2: 'struct PwPolyOpts *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_constant(arg1, arg2)
piecewise_poly_constant = _c3.piecewise_poly_constant

def piecewise_poly_zero(arg1: 'struct PwPolyOpts *', arg2: 'int') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_zero(arg1, arg2)
piecewise_poly_zero = _c3.piecewise_poly_zero

def piecewise_poly_linear(arg1: 'double', arg2: 'double', arg3: 'struct PwPolyOpts *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_linear(arg1, arg2, arg3)
piecewise_poly_linear = _c3.piecewise_poly_linear

def piecewise_poly_linear_update(arg1: 'PiecewisePoly', arg2: 'double', arg3: 'double') -> "int":
    return _c3.piecewise_poly_linear_update(arg1, arg2, arg3)
piecewise_poly_linear_update = _c3.piecewise_poly_linear_update

def piecewise_poly_quadratic(arg1: 'double', arg2: 'double', arg3: 'struct PwPolyOpts *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_quadratic(arg1, arg2, arg3)
piecewise_poly_quadratic = _c3.piecewise_poly_quadratic

def piecewise_poly_splitn(arg1: 'PiecewisePoly', arg2: 'size_t', arg3: 'double const *') -> "void":
    return _c3.piecewise_poly_splitn(arg1, arg2, arg3)
piecewise_poly_splitn = _c3.piecewise_poly_splitn

def piecewise_poly_isflat(arg1: 'PiecewisePoly') -> "int":
    return _c3.piecewise_poly_isflat(arg1)
piecewise_poly_isflat = _c3.piecewise_poly_isflat

def piecewise_poly_get_lb(arg1: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_get_lb(arg1)
piecewise_poly_get_lb = _c3.piecewise_poly_get_lb

def piecewise_poly_get_ub(arg1: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_get_ub(arg1)
piecewise_poly_get_ub = _c3.piecewise_poly_get_ub

def piecewise_poly_nregions_base(arg1: 'size_t *', arg2: 'PiecewisePoly') -> "void":
    return _c3.piecewise_poly_nregions_base(arg1, arg2)
piecewise_poly_nregions_base = _c3.piecewise_poly_nregions_base

def piecewise_poly_nregions(arg1: 'PiecewisePoly') -> "size_t":
    return _c3.piecewise_poly_nregions(arg1)
piecewise_poly_nregions = _c3.piecewise_poly_nregions

def piecewise_poly_boundaries(arg1: 'PiecewisePoly', arg2: 'size_t *', arg3: 'double **', arg4: 'size_t *') -> "void":
    return _c3.piecewise_poly_boundaries(arg1, arg2, arg3, arg4)
piecewise_poly_boundaries = _c3.piecewise_poly_boundaries

def piecewise_poly_eval(arg1: 'PiecewisePoly', arg2: 'double') -> "double":
    return _c3.piecewise_poly_eval(arg1, arg2)
piecewise_poly_eval = _c3.piecewise_poly_eval

def piecewise_poly_deriv_eval(arg1: 'PiecewisePoly', arg2: 'double') -> "double":
    return _c3.piecewise_poly_deriv_eval(arg1, arg2)
piecewise_poly_deriv_eval = _c3.piecewise_poly_deriv_eval

def piecewise_poly_evalN(arg1: 'PiecewisePoly', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t') -> "void":
    return _c3.piecewise_poly_evalN(arg1, arg2, arg3, arg4, arg5, arg6)
piecewise_poly_evalN = _c3.piecewise_poly_evalN

def piecewise_poly_scale(arg1: 'double', arg2: 'PiecewisePoly') -> "void":
    return _c3.piecewise_poly_scale(arg1, arg2)
piecewise_poly_scale = _c3.piecewise_poly_scale

def piecewise_poly_deriv(arg1: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_deriv(arg1)
piecewise_poly_deriv = _c3.piecewise_poly_deriv

def piecewise_poly_dderiv(arg1: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_dderiv(arg1)
piecewise_poly_dderiv = _c3.piecewise_poly_dderiv

def piecewise_poly_dderiv_periodic(arg1: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_dderiv_periodic(arg1)
piecewise_poly_dderiv_periodic = _c3.piecewise_poly_dderiv_periodic

def piecewise_poly_integrate(arg1: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_integrate(arg1)
piecewise_poly_integrate = _c3.piecewise_poly_integrate

def piecewise_poly_integrate_weighted(arg1: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_integrate_weighted(arg1)
piecewise_poly_integrate_weighted = _c3.piecewise_poly_integrate_weighted

def piecewise_poly_real_roots(arg1: 'PiecewisePoly', arg2: 'size_t *') -> "double *":
    return _c3.piecewise_poly_real_roots(arg1, arg2)
piecewise_poly_real_roots = _c3.piecewise_poly_real_roots

def piecewise_poly_max(arg1: 'PiecewisePoly', arg2: 'double *') -> "double":
    return _c3.piecewise_poly_max(arg1, arg2)
piecewise_poly_max = _c3.piecewise_poly_max

def piecewise_poly_min(arg1: 'PiecewisePoly', arg2: 'double *') -> "double":
    return _c3.piecewise_poly_min(arg1, arg2)
piecewise_poly_min = _c3.piecewise_poly_min

def piecewise_poly_absmax(arg1: 'PiecewisePoly', arg2: 'double *', arg3: 'void *') -> "double":
    return _c3.piecewise_poly_absmax(arg1, arg2, arg3)
piecewise_poly_absmax = _c3.piecewise_poly_absmax

def piecewise_poly_norm(arg1: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_norm(arg1)
piecewise_poly_norm = _c3.piecewise_poly_norm

def piecewise_poly_flip_sign(arg1: 'PiecewisePoly') -> "void":
    return _c3.piecewise_poly_flip_sign(arg1)
piecewise_poly_flip_sign = _c3.piecewise_poly_flip_sign

def piecewise_poly_copy_leaves(arg1: 'PiecewisePoly', arg2: 'struct PiecewisePoly **', arg3: 'size_t *') -> "void":
    return _c3.piecewise_poly_copy_leaves(arg1, arg2, arg3)
piecewise_poly_copy_leaves = _c3.piecewise_poly_copy_leaves

def piecewise_poly_ref_leaves(arg1: 'PiecewisePoly', arg2: 'struct PiecewisePoly **', arg3: 'size_t *') -> "void":
    return _c3.piecewise_poly_ref_leaves(arg1, arg2, arg3)
piecewise_poly_ref_leaves = _c3.piecewise_poly_ref_leaves

def piecewise_poly_flatten(arg1: 'PiecewisePoly') -> "void":
    return _c3.piecewise_poly_flatten(arg1)
piecewise_poly_flatten = _c3.piecewise_poly_flatten

def piecewise_poly_finer_grid(arg1: 'PiecewisePoly', arg2: 'size_t', arg3: 'double *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_finer_grid(arg1, arg2, arg3)
piecewise_poly_finer_grid = _c3.piecewise_poly_finer_grid

def piecewise_poly_match(arg1: 'PiecewisePoly', arg2: 'struct PiecewisePoly **', arg3: 'PiecewisePoly', arg4: 'struct PiecewisePoly **') -> "void":
    return _c3.piecewise_poly_match(arg1, arg2, arg3, arg4)
piecewise_poly_match = _c3.piecewise_poly_match

def piecewise_poly_prod(arg1: 'PiecewisePoly', arg2: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_prod(arg1, arg2)
piecewise_poly_prod = _c3.piecewise_poly_prod

def piecewise_poly_inner(arg1: 'PiecewisePoly', arg2: 'PiecewisePoly') -> "double":
    return _c3.piecewise_poly_inner(arg1, arg2)
piecewise_poly_inner = _c3.piecewise_poly_inner

def piecewise_poly_axpy(arg1: 'double', arg2: 'PiecewisePoly', arg3: 'PiecewisePoly') -> "int":
    return _c3.piecewise_poly_axpy(arg1, arg2, arg3)
piecewise_poly_axpy = _c3.piecewise_poly_axpy

def piecewise_poly_daxpby(arg1: 'double', arg2: 'PiecewisePoly', arg3: 'double', arg4: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_daxpby(arg1, arg2, arg3, arg4)
piecewise_poly_daxpby = _c3.piecewise_poly_daxpby

def piecewise_poly_matched_daxpby(arg1: 'double', arg2: 'PiecewisePoly', arg3: 'double', arg4: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_matched_daxpby(arg1, arg2, arg3, arg4)
piecewise_poly_matched_daxpby = _c3.piecewise_poly_matched_daxpby

def piecewise_poly_matched_prod(arg1: 'PiecewisePoly', arg2: 'PiecewisePoly') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_matched_prod(arg1, arg2)
piecewise_poly_matched_prod = _c3.piecewise_poly_matched_prod

def piecewise_poly_approx1(arg1: 'struct PwPolyOpts *', arg2: 'struct Fwrap *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_approx1(arg1, arg2)
piecewise_poly_approx1 = _c3.piecewise_poly_approx1

def piecewise_poly_approx1_adapt(arg1: 'struct PwPolyOpts *', arg2: 'struct Fwrap *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_approx1_adapt(arg1, arg2)
piecewise_poly_approx1_adapt = _c3.piecewise_poly_approx1_adapt

def piecewise_poly_check_discontinuity(arg1: 'PiecewisePoly', arg2: 'PiecewisePoly', arg3: 'int', arg4: 'double') -> "int":
    return _c3.piecewise_poly_check_discontinuity(arg1, arg2, arg3, arg4)
piecewise_poly_check_discontinuity = _c3.piecewise_poly_check_discontinuity

def minmod_eval(arg1: 'double', arg2: 'double *', arg3: 'double *', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t') -> "double":
    return _c3.minmod_eval(arg1, arg2, arg3, arg4, arg5, arg6)
minmod_eval = _c3.minmod_eval

def minmod_disc_exists(arg1: 'double', arg2: 'double *', arg3: 'double *', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t') -> "int":
    return _c3.minmod_disc_exists(arg1, arg2, arg3, arg4, arg5, arg6)
minmod_disc_exists = _c3.minmod_disc_exists

def locate_jumps(arg1: 'struct Fwrap *', arg2: 'double', arg3: 'double', arg4: 'size_t', arg5: 'double', arg6: 'double **', arg7: 'size_t *') -> "void":
    return _c3.locate_jumps(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
locate_jumps = _c3.locate_jumps

def serialize_piecewise_poly(arg1: 'unsigned char *', arg2: 'PiecewisePoly', arg3: 'size_t *') -> "unsigned char *":
    return _c3.serialize_piecewise_poly(arg1, arg2, arg3)
serialize_piecewise_poly = _c3.serialize_piecewise_poly

def deserialize_piecewise_poly(arg1: 'unsigned char *', arg2: 'struct PiecewisePoly **') -> "unsigned char *":
    return _c3.deserialize_piecewise_poly(arg1, arg2)
deserialize_piecewise_poly = _c3.deserialize_piecewise_poly

def print_piecewise_poly(pw: 'PiecewisePoly', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_piecewise_poly(pw, arg2, arg3, arg4)
print_piecewise_poly = _c3.print_piecewise_poly

def piecewise_poly_savetxt(arg1: 'PiecewisePoly', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.piecewise_poly_savetxt(arg1, arg2, arg3)
piecewise_poly_savetxt = _c3.piecewise_poly_savetxt

def piecewise_poly_loadtxt(arg1: 'FILE *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_loadtxt(arg1)
piecewise_poly_loadtxt = _c3.piecewise_poly_loadtxt

def piecewise_poly_get_num_params(arg1: 'PiecewisePoly') -> "size_t":
    return _c3.piecewise_poly_get_num_params(arg1)
piecewise_poly_get_num_params = _c3.piecewise_poly_get_num_params

def piecewise_poly_update_params(arg1: 'PiecewisePoly', arg2: 'size_t', arg3: 'double const *') -> "int":
    return _c3.piecewise_poly_update_params(arg1, arg2, arg3)
piecewise_poly_update_params = _c3.piecewise_poly_update_params

def piecewise_poly_param_grad_eval(arg1: 'PiecewisePoly', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "int":
    return _c3.piecewise_poly_param_grad_eval(arg1, arg2, arg3, arg4)
piecewise_poly_param_grad_eval = _c3.piecewise_poly_param_grad_eval

def piecewise_poly_param_grad_eval2(arg1: 'PiecewisePoly', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.piecewise_poly_param_grad_eval2(arg1, arg2, arg3)
piecewise_poly_param_grad_eval2 = _c3.piecewise_poly_param_grad_eval2

def piecewise_poly_squared_norm_param_grad(arg1: 'PiecewisePoly', arg2: 'double', arg3: 'double *') -> "int":
    return _c3.piecewise_poly_squared_norm_param_grad(arg1, arg2, arg3)
piecewise_poly_squared_norm_param_grad = _c3.piecewise_poly_squared_norm_param_grad

def piecewise_poly_get_params(arg1: 'PiecewisePoly', arg2: 'double *') -> "size_t":
    return _c3.piecewise_poly_get_params(arg1, arg2)
piecewise_poly_get_params = _c3.piecewise_poly_get_params

def piecewise_poly_get_params_ref(arg1: 'PiecewisePoly', arg2: 'size_t *') -> "double *":
    return _c3.piecewise_poly_get_params_ref(arg1, arg2)
piecewise_poly_get_params_ref = _c3.piecewise_poly_get_params_ref

def piecewise_poly_create_with_params(arg1: 'struct PwPolyOpts *', arg2: 'size_t', arg3: 'double const *') -> "struct PiecewisePoly *":
    return _c3.piecewise_poly_create_with_params(arg1, arg2, arg3)
piecewise_poly_create_with_params = _c3.piecewise_poly_create_with_params

def pivot_get_size(arg1: 'struct Pivot const *') -> "size_t":
    return _c3.pivot_get_size(arg1)
pivot_get_size = _c3.pivot_get_size

def pivot_get_ind(arg1: 'struct Pivot const *') -> "size_t":
    return _c3.pivot_get_ind(arg1)
pivot_get_ind = _c3.pivot_get_ind

def pivot_get_loc(arg1: 'struct Pivot const *') -> "void *":
    return _c3.pivot_get_loc(arg1)
pivot_get_loc = _c3.pivot_get_loc

def pivot_set_ind(arg1: 'struct Pivot *', arg2: 'size_t') -> "void":
    return _c3.pivot_set_ind(arg1, arg2)
pivot_set_ind = _c3.pivot_set_ind

def pivot_set_get_pivot(arg1: 'struct PivotSet *', arg2: 'size_t') -> "struct Pivot *":
    return _c3.pivot_set_get_pivot(arg1, arg2)
pivot_set_get_pivot = _c3.pivot_set_get_pivot

def space_mapping_map(arg1: 'struct SpaceMapping *', arg2: 'double') -> "double":
    return _c3.space_mapping_map(arg1, arg2)
space_mapping_map = _c3.space_mapping_map

def space_mapping_map_inverse(arg1: 'struct SpaceMapping *', arg2: 'double') -> "double":
    return _c3.space_mapping_map_inverse(arg1, arg2)
space_mapping_map_inverse = _c3.space_mapping_map_inverse

def space_mapping_map_deriv(arg1: 'struct SpaceMapping *', arg2: 'double') -> "double":
    return _c3.space_mapping_map_deriv(arg1, arg2)
space_mapping_map_deriv = _c3.space_mapping_map_deriv

def space_mapping_map_inverse_deriv(arg1: 'struct SpaceMapping *', arg2: 'double') -> "double":
    return _c3.space_mapping_map_inverse_deriv(arg1, arg2)
space_mapping_map_inverse_deriv = _c3.space_mapping_map_inverse_deriv
NONE = _c3.NONE
ALGEBRAIC = _c3.ALGEBRAIC
EXPONENTIAL = _c3.EXPONENTIAL
LEGENDRE = _c3.LEGENDRE
CHEBYSHEV = _c3.CHEBYSHEV
HERMITE = _c3.HERMITE
STANDARD = _c3.STANDARD
FOURIER = _c3.FOURIER

def ope_opts_alloc(arg1: 'enum poly_type') -> "struct OpeOpts *":
    return _c3.ope_opts_alloc(arg1)
ope_opts_alloc = _c3.ope_opts_alloc

def ope_opts_free(arg1: 'struct OpeOpts *') -> "void":
    return _c3.ope_opts_free(arg1)
ope_opts_free = _c3.ope_opts_free

def ope_opts_free_deep(arg1: 'struct OpeOpts **') -> "void":
    return _c3.ope_opts_free_deep(arg1)
ope_opts_free_deep = _c3.ope_opts_free_deep

def ope_opts_set_start(arg1: 'struct OpeOpts *', arg2: 'size_t') -> "void":
    return _c3.ope_opts_set_start(arg1, arg2)
ope_opts_set_start = _c3.ope_opts_set_start

def ope_opts_get_start(arg1: 'struct OpeOpts const *') -> "size_t":
    return _c3.ope_opts_get_start(arg1)
ope_opts_get_start = _c3.ope_opts_get_start

def ope_opts_set_maxnum(arg1: 'struct OpeOpts *', arg2: 'size_t') -> "void":
    return _c3.ope_opts_set_maxnum(arg1, arg2)
ope_opts_set_maxnum = _c3.ope_opts_set_maxnum

def ope_opts_get_maxnum(arg1: 'struct OpeOpts const *') -> "size_t":
    return _c3.ope_opts_get_maxnum(arg1)
ope_opts_get_maxnum = _c3.ope_opts_get_maxnum

def ope_opts_set_coeffs_check(arg1: 'struct OpeOpts *', arg2: 'size_t') -> "void":
    return _c3.ope_opts_set_coeffs_check(arg1, arg2)
ope_opts_set_coeffs_check = _c3.ope_opts_set_coeffs_check

def ope_opts_set_tol(arg1: 'struct OpeOpts *', arg2: 'double') -> "void":
    return _c3.ope_opts_set_tol(arg1, arg2)
ope_opts_set_tol = _c3.ope_opts_set_tol

def ope_opts_set_lb(arg1: 'struct OpeOpts *', arg2: 'double') -> "void":
    return _c3.ope_opts_set_lb(arg1, arg2)
ope_opts_set_lb = _c3.ope_opts_set_lb

def ope_opts_get_lb(arg1: 'struct OpeOpts const *') -> "double":
    return _c3.ope_opts_get_lb(arg1)
ope_opts_get_lb = _c3.ope_opts_get_lb

def ope_opts_set_ub(arg1: 'struct OpeOpts *', arg2: 'double') -> "void":
    return _c3.ope_opts_set_ub(arg1, arg2)
ope_opts_set_ub = _c3.ope_opts_set_ub

def ope_opts_get_ub(arg1: 'struct OpeOpts const *') -> "double":
    return _c3.ope_opts_get_ub(arg1)
ope_opts_get_ub = _c3.ope_opts_get_ub

def ope_opts_set_mean_and_std(arg1: 'struct OpeOpts *', arg2: 'double', arg3: 'double') -> "void":
    return _c3.ope_opts_set_mean_and_std(arg1, arg2, arg3)
ope_opts_set_mean_and_std = _c3.ope_opts_set_mean_and_std

def ope_opts_set_ptype(arg1: 'struct OpeOpts *', arg2: 'enum poly_type') -> "void":
    return _c3.ope_opts_set_ptype(arg1, arg2)
ope_opts_set_ptype = _c3.ope_opts_set_ptype

def ope_opts_get_ptype(arg1: 'struct OpeOpts const *') -> "enum poly_type":
    return _c3.ope_opts_get_ptype(arg1)
ope_opts_get_ptype = _c3.ope_opts_get_ptype

def ope_opts_set_qrule(arg1: 'struct OpeOpts *', arg2: 'enum quad_rule') -> "void":
    return _c3.ope_opts_set_qrule(arg1, arg2)
ope_opts_set_qrule = _c3.ope_opts_set_qrule

def ope_opts_get_nparams(arg1: 'struct OpeOpts const *') -> "size_t":
    return _c3.ope_opts_get_nparams(arg1)
ope_opts_get_nparams = _c3.ope_opts_get_nparams

def ope_opts_set_nparams(arg1: 'struct OpeOpts *', arg2: 'size_t') -> "void":
    return _c3.ope_opts_set_nparams(arg1, arg2)
ope_opts_set_nparams = _c3.ope_opts_set_nparams

def ope_opts_set_kristoffel_weight(arg1: 'struct OpeOpts *', arg2: 'int') -> "void":
    return _c3.ope_opts_set_kristoffel_weight(arg1, arg2)
ope_opts_set_kristoffel_weight = _c3.ope_opts_set_kristoffel_weight
class StandardPoly(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardPoly, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StandardPoly, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptype"] = _c3.StandardPoly_ptype_set
    __swig_getmethods__["ptype"] = _c3.StandardPoly_ptype_get
    if _newclass:
        ptype = _swig_property(_c3.StandardPoly_ptype_get, _c3.StandardPoly_ptype_set)
    __swig_setmethods__["num_poly"] = _c3.StandardPoly_num_poly_set
    __swig_getmethods__["num_poly"] = _c3.StandardPoly_num_poly_get
    if _newclass:
        num_poly = _swig_property(_c3.StandardPoly_num_poly_get, _c3.StandardPoly_num_poly_set)
    __swig_setmethods__["lower_bound"] = _c3.StandardPoly_lower_bound_set
    __swig_getmethods__["lower_bound"] = _c3.StandardPoly_lower_bound_get
    if _newclass:
        lower_bound = _swig_property(_c3.StandardPoly_lower_bound_get, _c3.StandardPoly_lower_bound_set)
    __swig_setmethods__["upper_bound"] = _c3.StandardPoly_upper_bound_set
    __swig_getmethods__["upper_bound"] = _c3.StandardPoly_upper_bound_get
    if _newclass:
        upper_bound = _swig_property(_c3.StandardPoly_upper_bound_get, _c3.StandardPoly_upper_bound_set)
    __swig_setmethods__["coeff"] = _c3.StandardPoly_coeff_set
    __swig_getmethods__["coeff"] = _c3.StandardPoly_coeff_get
    if _newclass:
        coeff = _swig_property(_c3.StandardPoly_coeff_get, _c3.StandardPoly_coeff_set)

    def __init__(self):
        this = _c3.new_StandardPoly()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_StandardPoly
    __del__ = lambda self: None
StandardPoly_swigregister = _c3.StandardPoly_swigregister
StandardPoly_swigregister(StandardPoly)


def standard_poly_init(arg1: 'size_t', arg2: 'double', arg3: 'double') -> "struct StandardPoly *":
    return _c3.standard_poly_init(arg1, arg2, arg3)
standard_poly_init = _c3.standard_poly_init

def standard_poly_deriv(arg1: 'StandardPoly') -> "struct StandardPoly *":
    return _c3.standard_poly_deriv(arg1)
standard_poly_deriv = _c3.standard_poly_deriv

def standard_poly_free(arg1: 'StandardPoly') -> "void":
    return _c3.standard_poly_free(arg1)
standard_poly_free = _c3.standard_poly_free
class OrthPoly(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrthPoly, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OrthPoly, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptype"] = _c3.OrthPoly_ptype_set
    __swig_getmethods__["ptype"] = _c3.OrthPoly_ptype_get
    if _newclass:
        ptype = _swig_property(_c3.OrthPoly_ptype_get, _c3.OrthPoly_ptype_set)
    __swig_setmethods__["an"] = _c3.OrthPoly_an_set
    __swig_getmethods__["an"] = _c3.OrthPoly_an_get
    if _newclass:
        an = _swig_property(_c3.OrthPoly_an_get, _c3.OrthPoly_an_set)
    __swig_setmethods__["bn"] = _c3.OrthPoly_bn_set
    __swig_getmethods__["bn"] = _c3.OrthPoly_bn_get
    if _newclass:
        bn = _swig_property(_c3.OrthPoly_bn_get, _c3.OrthPoly_bn_set)
    __swig_setmethods__["cn"] = _c3.OrthPoly_cn_set
    __swig_getmethods__["cn"] = _c3.OrthPoly_cn_get
    if _newclass:
        cn = _swig_property(_c3.OrthPoly_cn_get, _c3.OrthPoly_cn_set)
    __swig_setmethods__["lower"] = _c3.OrthPoly_lower_set
    __swig_getmethods__["lower"] = _c3.OrthPoly_lower_get
    if _newclass:
        lower = _swig_property(_c3.OrthPoly_lower_get, _c3.OrthPoly_lower_set)
    __swig_setmethods__["upper"] = _c3.OrthPoly_upper_set
    __swig_getmethods__["upper"] = _c3.OrthPoly_upper_get
    if _newclass:
        upper = _swig_property(_c3.OrthPoly_upper_get, _c3.OrthPoly_upper_set)
    __swig_setmethods__["const_term"] = _c3.OrthPoly_const_term_set
    __swig_getmethods__["const_term"] = _c3.OrthPoly_const_term_get
    if _newclass:
        const_term = _swig_property(_c3.OrthPoly_const_term_get, _c3.OrthPoly_const_term_set)
    __swig_setmethods__["lin_coeff"] = _c3.OrthPoly_lin_coeff_set
    __swig_getmethods__["lin_coeff"] = _c3.OrthPoly_lin_coeff_get
    if _newclass:
        lin_coeff = _swig_property(_c3.OrthPoly_lin_coeff_get, _c3.OrthPoly_lin_coeff_set)
    __swig_setmethods__["lin_const"] = _c3.OrthPoly_lin_const_set
    __swig_getmethods__["lin_const"] = _c3.OrthPoly_lin_const_get
    if _newclass:
        lin_const = _swig_property(_c3.OrthPoly_lin_const_get, _c3.OrthPoly_lin_const_set)
    __swig_setmethods__["norm"] = _c3.OrthPoly_norm_set
    __swig_getmethods__["norm"] = _c3.OrthPoly_norm_get
    if _newclass:
        norm = _swig_property(_c3.OrthPoly_norm_get, _c3.OrthPoly_norm_set)

    def __init__(self):
        this = _c3.new_OrthPoly()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_OrthPoly
    __del__ = lambda self: None
OrthPoly_swigregister = _c3.OrthPoly_swigregister
OrthPoly_swigregister(OrthPoly)


def init_cheb_poly() -> "struct OrthPoly *":
    return _c3.init_cheb_poly()
init_cheb_poly = _c3.init_cheb_poly

def init_leg_poly() -> "struct OrthPoly *":
    return _c3.init_leg_poly()
init_leg_poly = _c3.init_leg_poly

def free_orth_poly(arg1: 'OrthPoly') -> "void":
    return _c3.free_orth_poly(arg1)
free_orth_poly = _c3.free_orth_poly

def serialize_orth_poly(arg1: 'OrthPoly') -> "unsigned char *":
    return _c3.serialize_orth_poly(arg1)
serialize_orth_poly = _c3.serialize_orth_poly

def deserialize_orth_poly(arg1: 'unsigned char *') -> "struct OrthPoly *":
    return _c3.deserialize_orth_poly(arg1)
deserialize_orth_poly = _c3.deserialize_orth_poly

def orth_to_standard_poly(arg1: 'OrthPoly', arg2: 'size_t') -> "struct StandardPoly *":
    return _c3.orth_to_standard_poly(arg1, arg2)
orth_to_standard_poly = _c3.orth_to_standard_poly

def deriv_legen(arg1: 'double', arg2: 'size_t') -> "double":
    return _c3.deriv_legen(arg1, arg2)
deriv_legen = _c3.deriv_legen

def deriv_legen_upto(arg1: 'double', arg2: 'size_t') -> "double *":
    return _c3.deriv_legen_upto(arg1, arg2)
deriv_legen_upto = _c3.deriv_legen_upto

def orth_poly_eval(arg1: 'OrthPoly', arg2: 'size_t', arg3: 'double') -> "double":
    return _c3.orth_poly_eval(arg1, arg2, arg3)
orth_poly_eval = _c3.orth_poly_eval
class OrthPolyExpansion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrthPolyExpansion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OrthPolyExpansion, name)
    __repr__ = _swig_repr
    __swig_setmethods__["p"] = _c3.OrthPolyExpansion_p_set
    __swig_getmethods__["p"] = _c3.OrthPolyExpansion_p_get
    if _newclass:
        p = _swig_property(_c3.OrthPolyExpansion_p_get, _c3.OrthPolyExpansion_p_set)
    __swig_setmethods__["num_poly"] = _c3.OrthPolyExpansion_num_poly_set
    __swig_getmethods__["num_poly"] = _c3.OrthPolyExpansion_num_poly_get
    if _newclass:
        num_poly = _swig_property(_c3.OrthPolyExpansion_num_poly_get, _c3.OrthPolyExpansion_num_poly_set)
    __swig_setmethods__["lower_bound"] = _c3.OrthPolyExpansion_lower_bound_set
    __swig_getmethods__["lower_bound"] = _c3.OrthPolyExpansion_lower_bound_get
    if _newclass:
        lower_bound = _swig_property(_c3.OrthPolyExpansion_lower_bound_get, _c3.OrthPolyExpansion_lower_bound_set)
    __swig_setmethods__["upper_bound"] = _c3.OrthPolyExpansion_upper_bound_set
    __swig_getmethods__["upper_bound"] = _c3.OrthPolyExpansion_upper_bound_get
    if _newclass:
        upper_bound = _swig_property(_c3.OrthPolyExpansion_upper_bound_get, _c3.OrthPolyExpansion_upper_bound_set)
    __swig_setmethods__["coeff"] = _c3.OrthPolyExpansion_coeff_set
    __swig_getmethods__["coeff"] = _c3.OrthPolyExpansion_coeff_get
    if _newclass:
        coeff = _swig_property(_c3.OrthPolyExpansion_coeff_get, _c3.OrthPolyExpansion_coeff_set)
    __swig_setmethods__["ccoeff"] = _c3.OrthPolyExpansion_ccoeff_set
    __swig_getmethods__["ccoeff"] = _c3.OrthPolyExpansion_ccoeff_get
    if _newclass:
        ccoeff = _swig_property(_c3.OrthPolyExpansion_ccoeff_get, _c3.OrthPolyExpansion_ccoeff_set)
    __swig_setmethods__["nalloc"] = _c3.OrthPolyExpansion_nalloc_set
    __swig_getmethods__["nalloc"] = _c3.OrthPolyExpansion_nalloc_get
    if _newclass:
        nalloc = _swig_property(_c3.OrthPolyExpansion_nalloc_get, _c3.OrthPolyExpansion_nalloc_set)
    __swig_setmethods__["space_transform"] = _c3.OrthPolyExpansion_space_transform_set
    __swig_getmethods__["space_transform"] = _c3.OrthPolyExpansion_space_transform_get
    if _newclass:
        space_transform = _swig_property(_c3.OrthPolyExpansion_space_transform_get, _c3.OrthPolyExpansion_space_transform_set)
    __swig_setmethods__["kristoffel_eval"] = _c3.OrthPolyExpansion_kristoffel_eval_set
    __swig_getmethods__["kristoffel_eval"] = _c3.OrthPolyExpansion_kristoffel_eval_get
    if _newclass:
        kristoffel_eval = _swig_property(_c3.OrthPolyExpansion_kristoffel_eval_get, _c3.OrthPolyExpansion_kristoffel_eval_set)

    def __init__(self):
        this = _c3.new_OrthPolyExpansion()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_OrthPolyExpansion
    __del__ = lambda self: None
OrthPolyExpansion_swigregister = _c3.OrthPolyExpansion_swigregister
OrthPolyExpansion_swigregister(OrthPolyExpansion)

OPECALLOC = _c3.OPECALLOC

def orth_poly_expansion_get_num_poly(arg1: 'OrthPolyExpansion') -> "size_t":
    return _c3.orth_poly_expansion_get_num_poly(arg1)
orth_poly_expansion_get_num_poly = _c3.orth_poly_expansion_get_num_poly

def orth_poly_expansion_get_num_params(arg1: 'OrthPolyExpansion') -> "size_t":
    return _c3.orth_poly_expansion_get_num_params(arg1)
orth_poly_expansion_get_num_params = _c3.orth_poly_expansion_get_num_params

def orth_poly_expansion_get_lb(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_get_lb(arg1)
orth_poly_expansion_get_lb = _c3.orth_poly_expansion_get_lb

def orth_poly_expansion_get_ub(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_get_ub(arg1)
orth_poly_expansion_get_ub = _c3.orth_poly_expansion_get_ub

def orth_poly_expansion_init(arg1: 'enum poly_type', arg2: 'size_t', arg3: 'double', arg4: 'double') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_init(arg1, arg2, arg3, arg4)
orth_poly_expansion_init = _c3.orth_poly_expansion_init

def orth_poly_expansion_init_from_opts(arg1: 'struct OpeOpts const *', arg2: 'size_t') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_init_from_opts(arg1, arg2)
orth_poly_expansion_init_from_opts = _c3.orth_poly_expansion_init_from_opts

def orth_poly_expansion_create_with_params(arg1: 'struct OpeOpts *', arg2: 'size_t', arg3: 'double const *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_create_with_params(arg1, arg2, arg3)
orth_poly_expansion_create_with_params = _c3.orth_poly_expansion_create_with_params

def orth_poly_expansion_get_params(arg1: 'OrthPolyExpansion', arg2: 'double *') -> "size_t":
    return _c3.orth_poly_expansion_get_params(arg1, arg2)
orth_poly_expansion_get_params = _c3.orth_poly_expansion_get_params

def orth_poly_expansion_get_params_ref(arg1: 'OrthPolyExpansion', arg2: 'size_t *') -> "double *":
    return _c3.orth_poly_expansion_get_params_ref(arg1, arg2)
orth_poly_expansion_get_params_ref = _c3.orth_poly_expansion_get_params_ref

def orth_poly_expansion_update_params(arg1: 'OrthPolyExpansion', arg2: 'size_t', arg3: 'double const *') -> "int":
    return _c3.orth_poly_expansion_update_params(arg1, arg2, arg3)
orth_poly_expansion_update_params = _c3.orth_poly_expansion_update_params

def orth_poly_expansion_copy(arg1: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_copy(arg1)
orth_poly_expansion_copy = _c3.orth_poly_expansion_copy

def orth_poly_expansion_get_ptype(arg1: 'OrthPolyExpansion') -> "enum poly_type":
    return _c3.orth_poly_expansion_get_ptype(arg1)
orth_poly_expansion_get_ptype = _c3.orth_poly_expansion_get_ptype

def orth_poly_expansion_zero(arg1: 'struct OpeOpts *', arg2: 'int') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_zero(arg1, arg2)
orth_poly_expansion_zero = _c3.orth_poly_expansion_zero

def orth_poly_expansion_constant(arg1: 'double', arg2: 'struct OpeOpts *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_constant(arg1, arg2)
orth_poly_expansion_constant = _c3.orth_poly_expansion_constant

def orth_poly_expansion_linear(arg1: 'double', arg2: 'double', arg3: 'struct OpeOpts *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_linear(arg1, arg2, arg3)
orth_poly_expansion_linear = _c3.orth_poly_expansion_linear

def orth_poly_expansion_linear_update(arg1: 'OrthPolyExpansion', arg2: 'double', arg3: 'double') -> "int":
    return _c3.orth_poly_expansion_linear_update(arg1, arg2, arg3)
orth_poly_expansion_linear_update = _c3.orth_poly_expansion_linear_update

def orth_poly_expansion_quadratic(arg1: 'double', arg2: 'double', arg3: 'struct OpeOpts *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_quadratic(arg1, arg2, arg3)
orth_poly_expansion_quadratic = _c3.orth_poly_expansion_quadratic

def orth_poly_expansion_genorder(arg1: 'size_t', arg2: 'struct OpeOpts *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_genorder(arg1, arg2)
orth_poly_expansion_genorder = _c3.orth_poly_expansion_genorder

def orth_poly_expansion_orth_basis(arg1: 'size_t', arg2: 'struct OrthPolyExpansion **', arg3: 'struct OpeOpts *') -> "void":
    return _c3.orth_poly_expansion_orth_basis(arg1, arg2, arg3)
orth_poly_expansion_orth_basis = _c3.orth_poly_expansion_orth_basis

def orth_poly_expansion_deriv_eval(arg1: 'OrthPolyExpansion', arg2: 'double') -> "double":
    return _c3.orth_poly_expansion_deriv_eval(arg1, arg2)
orth_poly_expansion_deriv_eval = _c3.orth_poly_expansion_deriv_eval

def orth_poly_expansion_deriv(arg1: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_deriv(arg1)
orth_poly_expansion_deriv = _c3.orth_poly_expansion_deriv

def orth_poly_expansion_dderiv(arg1: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_dderiv(arg1)
orth_poly_expansion_dderiv = _c3.orth_poly_expansion_dderiv

def orth_poly_expansion_dderiv_periodic(arg1: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_dderiv_periodic(arg1)
orth_poly_expansion_dderiv_periodic = _c3.orth_poly_expansion_dderiv_periodic

def orth_poly_expansion_free(arg1: 'OrthPolyExpansion') -> "void":
    return _c3.orth_poly_expansion_free(arg1)
orth_poly_expansion_free = _c3.orth_poly_expansion_free

def serialize_orth_poly_expansion(arg1: 'unsigned char *', arg2: 'OrthPolyExpansion', arg3: 'size_t *') -> "unsigned char *":
    return _c3.serialize_orth_poly_expansion(arg1, arg2, arg3)
serialize_orth_poly_expansion = _c3.serialize_orth_poly_expansion

def deserialize_orth_poly_expansion(arg1: 'unsigned char *', arg2: 'struct OrthPolyExpansion **') -> "unsigned char *":
    return _c3.deserialize_orth_poly_expansion(arg1, arg2)
deserialize_orth_poly_expansion = _c3.deserialize_orth_poly_expansion

def orth_poly_expansion_savetxt(arg1: 'OrthPolyExpansion', arg2: 'FILE *', arg3: 'size_t') -> "void":
    return _c3.orth_poly_expansion_savetxt(arg1, arg2, arg3)
orth_poly_expansion_savetxt = _c3.orth_poly_expansion_savetxt

def orth_poly_expansion_loadtxt(arg1: 'FILE *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_loadtxt(arg1)
orth_poly_expansion_loadtxt = _c3.orth_poly_expansion_loadtxt

def orth_poly_expansion_to_standard_poly(arg1: 'OrthPolyExpansion') -> "struct StandardPoly *":
    return _c3.orth_poly_expansion_to_standard_poly(arg1)
orth_poly_expansion_to_standard_poly = _c3.orth_poly_expansion_to_standard_poly

def orth_poly_expansion_arr_eval(arg1: 'size_t', arg2: 'struct OrthPolyExpansion **', arg3: 'double', arg4: 'double *') -> "int":
    return _c3.orth_poly_expansion_arr_eval(arg1, arg2, arg3, arg4)
orth_poly_expansion_arr_eval = _c3.orth_poly_expansion_arr_eval

def orth_poly_expansion_arr_evalN(arg1: 'size_t', arg2: 'struct OrthPolyExpansion **', arg3: 'size_t', arg4: 'double const *', arg5: 'size_t', arg6: 'double *', arg7: 'size_t') -> "int":
    return _c3.orth_poly_expansion_arr_evalN(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
orth_poly_expansion_arr_evalN = _c3.orth_poly_expansion_arr_evalN

def chebyshev_poly_expansion_eval(arg1: 'OrthPolyExpansion', arg2: 'double') -> "double":
    return _c3.chebyshev_poly_expansion_eval(arg1, arg2)
chebyshev_poly_expansion_eval = _c3.chebyshev_poly_expansion_eval

def orth_poly_expansion_eval(arg1: 'OrthPolyExpansion', arg2: 'double') -> "double":
    return _c3.orth_poly_expansion_eval(arg1, arg2)
orth_poly_expansion_eval = _c3.orth_poly_expansion_eval

def orth_poly_expansion_get_kristoffel_weight(arg1: 'OrthPolyExpansion', arg2: 'double') -> "double":
    return _c3.orth_poly_expansion_get_kristoffel_weight(arg1, arg2)
orth_poly_expansion_get_kristoffel_weight = _c3.orth_poly_expansion_get_kristoffel_weight

def orth_poly_expansion_evalN(arg1: 'OrthPolyExpansion', arg2: 'size_t', arg3: 'double const *', arg4: 'size_t', arg5: 'double *', arg6: 'size_t') -> "void":
    return _c3.orth_poly_expansion_evalN(arg1, arg2, arg3, arg4, arg5, arg6)
orth_poly_expansion_evalN = _c3.orth_poly_expansion_evalN

def orth_poly_expansion_param_grad_eval(arg1: 'OrthPolyExpansion', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "int":
    return _c3.orth_poly_expansion_param_grad_eval(arg1, arg2, arg3, arg4)
orth_poly_expansion_param_grad_eval = _c3.orth_poly_expansion_param_grad_eval

def orth_poly_expansion_param_grad_eval2(arg1: 'OrthPolyExpansion', arg2: 'double', arg3: 'double *') -> "double":
    return _c3.orth_poly_expansion_param_grad_eval2(arg1, arg2, arg3)
orth_poly_expansion_param_grad_eval2 = _c3.orth_poly_expansion_param_grad_eval2

def orth_poly_expansion_squared_norm_param_grad(arg1: 'OrthPolyExpansion', arg2: 'double', arg3: 'double *') -> "int":
    return _c3.orth_poly_expansion_squared_norm_param_grad(arg1, arg2, arg3)
orth_poly_expansion_squared_norm_param_grad = _c3.orth_poly_expansion_squared_norm_param_grad

def orth_poly_expansion_rkhs_squared_norm(arg1: 'OrthPolyExpansion', arg2: 'enum coeff_decay_type', arg3: 'double') -> "double":
    return _c3.orth_poly_expansion_rkhs_squared_norm(arg1, arg2, arg3)
orth_poly_expansion_rkhs_squared_norm = _c3.orth_poly_expansion_rkhs_squared_norm

def orth_poly_expansion_rkhs_squared_norm_param_grad(arg1: 'OrthPolyExpansion', arg2: 'double', arg3: 'enum coeff_decay_type', arg4: 'double', arg5: 'double *') -> "int":
    return _c3.orth_poly_expansion_rkhs_squared_norm_param_grad(arg1, arg2, arg3, arg4, arg5)
orth_poly_expansion_rkhs_squared_norm_param_grad = _c3.orth_poly_expansion_rkhs_squared_norm_param_grad

def orth_poly_expansion_round(arg1: 'struct OrthPolyExpansion **') -> "void":
    return _c3.orth_poly_expansion_round(arg1)
orth_poly_expansion_round = _c3.orth_poly_expansion_round

def orth_poly_expansion_roundt(arg1: 'struct OrthPolyExpansion **', arg2: 'double') -> "void":
    return _c3.orth_poly_expansion_roundt(arg1, arg2)
orth_poly_expansion_roundt = _c3.orth_poly_expansion_roundt

def orth_poly_expansion_approx(arg1: 'double (*)(double,void *)', arg2: 'void *', arg3: 'OrthPolyExpansion') -> "void":
    return _c3.orth_poly_expansion_approx(arg1, arg2, arg3)
orth_poly_expansion_approx = _c3.orth_poly_expansion_approx

def orth_poly_expansion_approx_vec(arg1: 'OrthPolyExpansion', arg2: 'struct Fwrap *', arg3: 'struct OpeOpts const *') -> "int":
    return _c3.orth_poly_expansion_approx_vec(arg1, arg2, arg3)
orth_poly_expansion_approx_vec = _c3.orth_poly_expansion_approx_vec

def orth_poly_expansion_approx_adapt(arg1: 'struct OpeOpts const *', arg2: 'struct Fwrap *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_approx_adapt(arg1, arg2)
orth_poly_expansion_approx_adapt = _c3.orth_poly_expansion_approx_adapt

def orth_poly_expansion_randu(arg1: 'enum poly_type', arg2: 'size_t', arg3: 'double', arg4: 'double') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_randu(arg1, arg2, arg3, arg4)
orth_poly_expansion_randu = _c3.orth_poly_expansion_randu

def cheb_integrate2(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.cheb_integrate2(arg1)
cheb_integrate2 = _c3.cheb_integrate2

def legendre_integrate(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.legendre_integrate(arg1)
legendre_integrate = _c3.legendre_integrate

def orth_poly_expansion_prod(arg1: 'OrthPolyExpansion', arg2: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_prod(arg1, arg2)
orth_poly_expansion_prod = _c3.orth_poly_expansion_prod

def orth_poly_expansion_sum_prod(arg1: 'size_t', arg2: 'size_t', arg3: 'struct OrthPolyExpansion **', arg4: 'size_t', arg5: 'struct OrthPolyExpansion **') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_sum_prod(arg1, arg2, arg3, arg4, arg5)
orth_poly_expansion_sum_prod = _c3.orth_poly_expansion_sum_prod

def orth_poly_expansion_integrate(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_integrate(arg1)
orth_poly_expansion_integrate = _c3.orth_poly_expansion_integrate

def orth_poly_expansion_integrate_weighted(arg1: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_integrate_weighted(arg1)
orth_poly_expansion_integrate_weighted = _c3.orth_poly_expansion_integrate_weighted

def orth_poly_expansion_inner_w(arg1: 'OrthPolyExpansion', arg2: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_inner_w(arg1, arg2)
orth_poly_expansion_inner_w = _c3.orth_poly_expansion_inner_w

def orth_poly_expansion_inner(arg1: 'OrthPolyExpansion', arg2: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_inner(arg1, arg2)
orth_poly_expansion_inner = _c3.orth_poly_expansion_inner

def orth_poly_expansion_norm_w(p: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_norm_w(p)
orth_poly_expansion_norm_w = _c3.orth_poly_expansion_norm_w

def orth_poly_expansion_norm(p: 'OrthPolyExpansion') -> "double":
    return _c3.orth_poly_expansion_norm(p)
orth_poly_expansion_norm = _c3.orth_poly_expansion_norm

def orth_poly_expansion_flip_sign(arg1: 'OrthPolyExpansion') -> "void":
    return _c3.orth_poly_expansion_flip_sign(arg1)
orth_poly_expansion_flip_sign = _c3.orth_poly_expansion_flip_sign

def orth_poly_expansion_scale(arg1: 'double', arg2: 'OrthPolyExpansion') -> "void":
    return _c3.orth_poly_expansion_scale(arg1, arg2)
orth_poly_expansion_scale = _c3.orth_poly_expansion_scale

def orth_poly_expansion_daxpby(arg1: 'double', arg2: 'OrthPolyExpansion', arg3: 'double', arg4: 'OrthPolyExpansion') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_daxpby(arg1, arg2, arg3, arg4)
orth_poly_expansion_daxpby = _c3.orth_poly_expansion_daxpby

def orth_poly_expansion_axpy(a: 'double', x: 'OrthPolyExpansion', y: 'OrthPolyExpansion') -> "int":
    return _c3.orth_poly_expansion_axpy(a, x, y)
orth_poly_expansion_axpy = _c3.orth_poly_expansion_axpy

def orth_poly_expansion_sum3_up(arg1: 'double', arg2: 'OrthPolyExpansion', arg3: 'double', arg4: 'OrthPolyExpansion', arg5: 'double', arg6: 'OrthPolyExpansion') -> "void":
    return _c3.orth_poly_expansion_sum3_up(arg1, arg2, arg3, arg4, arg5, arg6)
orth_poly_expansion_sum3_up = _c3.orth_poly_expansion_sum3_up

def orth_poly_expansion_lin_comb(arg1: 'size_t', arg2: 'size_t', arg3: 'struct OrthPolyExpansion **', arg4: 'size_t', arg5: 'double const *') -> "struct OrthPolyExpansion *":
    return _c3.orth_poly_expansion_lin_comb(arg1, arg2, arg3, arg4, arg5)
orth_poly_expansion_lin_comb = _c3.orth_poly_expansion_lin_comb

def legendre_expansion_real_roots(arg1: 'OrthPolyExpansion', arg2: 'size_t *') -> "double *":
    return _c3.legendre_expansion_real_roots(arg1, arg2)
legendre_expansion_real_roots = _c3.legendre_expansion_real_roots

def standard_poly_real_roots(arg1: 'StandardPoly', arg2: 'size_t *') -> "double *":
    return _c3.standard_poly_real_roots(arg1, arg2)
standard_poly_real_roots = _c3.standard_poly_real_roots

def orth_poly_expansion_real_roots(arg1: 'OrthPolyExpansion', arg2: 'size_t *') -> "double *":
    return _c3.orth_poly_expansion_real_roots(arg1, arg2)
orth_poly_expansion_real_roots = _c3.orth_poly_expansion_real_roots

def orth_poly_expansion_max(arg1: 'OrthPolyExpansion', arg2: 'double *') -> "double":
    return _c3.orth_poly_expansion_max(arg1, arg2)
orth_poly_expansion_max = _c3.orth_poly_expansion_max

def orth_poly_expansion_min(arg1: 'OrthPolyExpansion', arg2: 'double *') -> "double":
    return _c3.orth_poly_expansion_min(arg1, arg2)
orth_poly_expansion_min = _c3.orth_poly_expansion_min

def orth_poly_expansion_absmax(arg1: 'OrthPolyExpansion', arg2: 'double *', arg3: 'void *') -> "double":
    return _c3.orth_poly_expansion_absmax(arg1, arg2, arg3)
orth_poly_expansion_absmax = _c3.orth_poly_expansion_absmax

def print_orth_poly_expansion(arg1: 'OrthPolyExpansion', arg2: 'size_t', arg3: 'void *', arg4: 'FILE *') -> "void":
    return _c3.print_orth_poly_expansion(arg1, arg2, arg3, arg4)
print_orth_poly_expansion = _c3.print_orth_poly_expansion

def bounding_box_init_std(arg1: 'size_t') -> "struct BoundingBox *":
    return _c3.bounding_box_init_std(arg1)
bounding_box_init_std = _c3.bounding_box_init_std

def bounding_box_init(arg1: 'size_t', arg2: 'double', arg3: 'double') -> "struct BoundingBox *":
    return _c3.bounding_box_init(arg1, arg2, arg3)
bounding_box_init = _c3.bounding_box_init

def bounding_box_vec(arg1: 'size_t', arg2: 'double const *', arg3: 'double const *') -> "struct BoundingBox *":
    return _c3.bounding_box_vec(arg1, arg2, arg3)
bounding_box_vec = _c3.bounding_box_vec

def bounding_box_free(arg1: 'struct BoundingBox *') -> "void":
    return _c3.bounding_box_free(arg1)
bounding_box_free = _c3.bounding_box_free

def bounding_box_get_dim(arg1: 'struct BoundingBox const *') -> "size_t":
    return _c3.bounding_box_get_dim(arg1)
bounding_box_get_dim = _c3.bounding_box_get_dim

def bounding_box_get_lb(arg1: 'struct BoundingBox const *') -> "double *":
    return _c3.bounding_box_get_lb(arg1)
bounding_box_get_lb = _c3.bounding_box_get_lb

def bounding_box_get_ub(arg1: 'struct BoundingBox const *') -> "double *":
    return _c3.bounding_box_get_ub(arg1)
bounding_box_get_ub = _c3.bounding_box_get_ub

def bounding_box_get_ub_dim(arg1: 'struct BoundingBox const *', arg2: 'size_t') -> "double":
    return _c3.bounding_box_get_ub_dim(arg1, arg2)
bounding_box_get_ub_dim = _c3.bounding_box_get_ub_dim

def bounding_box_set_ub_dim(arg1: 'struct BoundingBox *', arg2: 'size_t', arg3: 'double') -> "void":
    return _c3.bounding_box_set_ub_dim(arg1, arg2, arg3)
bounding_box_set_ub_dim = _c3.bounding_box_set_ub_dim

def bounding_box_get_lb_dim(arg1: 'struct BoundingBox const *', arg2: 'size_t') -> "double":
    return _c3.bounding_box_get_lb_dim(arg1, arg2)
bounding_box_get_lb_dim = _c3.bounding_box_get_lb_dim

def bounding_box_set_lb_dim(arg1: 'struct BoundingBox *', arg2: 'size_t', arg3: 'double') -> "void":
    return _c3.bounding_box_set_lb_dim(arg1, arg2, arg3)
bounding_box_set_lb_dim = _c3.bounding_box_set_lb_dim

def dgetri_(X: 'int *', Y: 'double *', Z: 'int *', A: 'int *', B: 'double *', C: 'int *', D: 'int *') -> "void":
    return _c3.dgetri_(X, Y, Z, A, B, C, D)
dgetri_ = _c3.dgetri_

def dgetrf_(X: 'int *', Y: 'int *', Z: 'double *', A: 'int *', B: 'int *', C: 'int *') -> "void":
    return _c3.dgetrf_(X, Y, Z, A, B, C)
dgetrf_ = _c3.dgetrf_

def dorgqr_(X: 'int *', Y: 'int *', Z: 'int *', A: 'double *', B: 'int *', C: 'double *', D: 'double *', E: 'int *', F: 'int *') -> "void":
    return _c3.dorgqr_(X, Y, Z, A, B, C, D, E, F)
dorgqr_ = _c3.dorgqr_

def dgeqrf_(X: 'int *', Y: 'int *', Z: 'double *', A: 'int *', B: 'double *', C: 'double *', D: 'int *', E: 'int *') -> "void":
    return _c3.dgeqrf_(X, Y, Z, A, B, C, D, E)
dgeqrf_ = _c3.dgeqrf_

def dgeev_(X: 'char *', Y: 'char *', Z: 'int *', A: 'double *', B: 'int *', C: 'double *', D: 'double *', E: 'double *', F: 'int *', G: 'double *', H: 'int *', arg12: 'double *', arg13: 'int *', K: 'int *') -> "void":
    return _c3.dgeev_(X, Y, Z, A, B, C, D, E, F, G, H, arg12, arg13, K)
dgeev_ = _c3.dgeev_

def dgebal_(X: 'char *', Y: 'int *', Z: 'double *', A: 'int *', B: 'int *', C: 'int *', D: 'double *', E: 'int *') -> "void":
    return _c3.dgebal_(X, Y, Z, A, B, C, D, E)
dgebal_ = _c3.dgebal_

def dhseqr_(X: 'char *', Y: 'char *', Z: 'int *', A: 'int *', B: 'int *', C: 'double *', D: 'int *', E: 'double *', F: 'double *', G: 'double *', H: 'int *', arg12: 'double *', arg13: 'int *', K: 'int *') -> "void":
    return _c3.dhseqr_(X, Y, Z, A, B, C, D, E, F, G, H, arg12, arg13, K)
dhseqr_ = _c3.dhseqr_

def dorgrq_(X: 'int *', Y: 'int *', Z: 'int *', A: 'double *', B: 'int *', C: 'double *', D: 'double *', E: 'int *', F: 'int *') -> "void":
    return _c3.dorgrq_(X, Y, Z, A, B, C, D, E, F)
dorgrq_ = _c3.dorgrq_

def dgerqf_(X: 'int *', Y: 'int *', Z: 'double *', A: 'int *', B: 'double *', C: 'double *', D: 'int *', E: 'int *') -> "void":
    return _c3.dgerqf_(X, Y, Z, A, B, C, D, E)
dgerqf_ = _c3.dgerqf_

def dgesdd_(X: 'char *', Y: 'int *', Z: 'int *', A: 'double *', B: 'int *', C: 'double *', D: 'double *', E: 'int *', F: 'double *', G: 'int *', H: 'double *', arg12: 'int *', arg13: 'int *', K: 'int *') -> "void":
    return _c3.dgesdd_(X, Y, Z, A, B, C, D, E, F, G, H, arg12, arg13, K)
dgesdd_ = _c3.dgesdd_

def dstev_(X: 'char *', Y: 'int *', Z: 'double *', A: 'double *', B: 'double *', C: 'int *', D: 'double *', E: 'int *') -> "void":
    return _c3.dstev_(X, Y, Z, A, B, C, D, E)
dstev_ = _c3.dstev_

def dsyev_(A: 'char *', B: 'char *', C: 'int *', D: 'double *', E: 'int *', F: 'double *', G: 'double *', H: 'int *', J: 'int *') -> "void":
    return _c3.dsyev_(A, B, C, D, E, F, G, H, J)
dsyev_ = _c3.dsyev_

def dpotrf_(X: 'char *', Y: 'int *', Z: 'double *', A: 'int *', B: 'int *') -> "void":
    return _c3.dpotrf_(X, Y, Z, A, B)
dpotrf_ = _c3.dpotrf_

def dpotri_(X: 'char *', Y: 'int *', Z: 'double *', A: 'int *', B: 'int *') -> "void":
    return _c3.dpotri_(X, Y, Z, A, B)
dpotri_ = _c3.dpotri_

def dtrtri_(X: 'char *', Y: 'char *', Z: 'int *', A: 'double *', B: 'int *', C: 'int *') -> "void":
    return _c3.dtrtri_(X, Y, Z, A, B, C)
dtrtri_ = _c3.dtrtri_

def dgesv_(X: 'int *', Y: 'int *', Z: 'double *', A: 'int *', B: 'int *', C: 'double *', D: 'int *', E: 'int *') -> "void":
    return _c3.dgesv_(X, Y, Z, A, B, C, D, E)
dgesv_ = _c3.dgesv_

def dgelsd_(X: 'int *', Y: 'int *', Z: 'int *', A: 'double *', B: 'int *', C: 'double *', D: 'int *', E: 'double *', F: 'double *', G: 'int *', H: 'double *', arg12: 'int *', arg13: 'int *', K: 'int *') -> "void":
    return _c3.dgelsd_(X, Y, Z, A, B, C, D, E, F, G, H, arg12, arg13, K)
dgelsd_ = _c3.dgelsd_

def c3linalg_multiple_vec_mat(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double const *', arg5: 'size_t', arg6: 'double const *', arg7: 'size_t', arg8: 'double *', arg9: 'size_t') -> "void":
    return _c3.c3linalg_multiple_vec_mat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
c3linalg_multiple_vec_mat = _c3.c3linalg_multiple_vec_mat

def c3linalg_multiple_mat_vec(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double const *', arg5: 'size_t', arg6: 'double const *', arg7: 'size_t', arg8: 'double *', arg9: 'size_t') -> "void":
    return _c3.c3linalg_multiple_mat_vec(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
c3linalg_multiple_mat_vec = _c3.c3linalg_multiple_mat_vec

def qr(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'size_t') -> "int":
    return _c3.qr(arg1, arg2, arg3, arg4)
qr = _c3.qr

def rq_with_rmult(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t', arg7: 'double *', arg8: 'size_t') -> "void":
    return _c3.rq_with_rmult(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
rq_with_rmult = _c3.rq_with_rmult

def svd(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *') -> "void":
    return _c3.svd(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
svd = _c3.svd

def truncated_svd(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double *', arg5: 'double **', arg6: 'double **', arg7: 'double **', arg8: 'double') -> "size_t":
    return _c3.truncated_svd(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
truncated_svd = _c3.truncated_svd

def pinv(arg1: 'size_t', arg2: 'size_t', arg3: 'size_t', arg4: 'double *', arg5: 'double *', arg6: 'double') -> "size_t":
    return _c3.pinv(arg1, arg2, arg3, arg4, arg5, arg6)
pinv = _c3.pinv

def norm2(arg1: 'double *', arg2: 'int') -> "double":
    return _c3.norm2(arg1, arg2)
norm2 = _c3.norm2

def norm2diff(arg1: 'double *', arg2: 'double *', arg3: 'int') -> "double":
    return _c3.norm2diff(arg1, arg2, arg3)
norm2diff = _c3.norm2diff

def mean(arg1: 'double *', arg2: 'size_t') -> "double":
    return _c3.mean(arg1, arg2)
mean = _c3.mean

def mean_size_t(arg1: 'size_t *', arg2: 'size_t') -> "double":
    return _c3.mean_size_t(arg1, arg2)
mean_size_t = _c3.mean_size_t

def kron(arg1: 'mat', arg2: 'mat') -> "struct mat *":
    return _c3.kron(arg1, arg2)
kron = _c3.kron

def kron_col(arg1: 'int', arg2: 'int', arg3: 'double *', arg4: 'int', arg5: 'int', arg6: 'int', arg7: 'double *', arg8: 'int', arg9: 'double *', arg10: 'int') -> "void":
    return _c3.kron_col(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
kron_col = _c3.kron_col

def vec_kron(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t', arg7: 'double *', arg8: 'size_t', arg9: 'double *', arg10: 'double', arg11: 'double *') -> "void":
    return _c3.vec_kron(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
vec_kron = _c3.vec_kron

def vec_kronl(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t', arg7: 'double *', arg8: 'size_t', arg9: 'long double *', arg10: 'double', arg11: 'long double *') -> "void":
    return _c3.vec_kronl(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
vec_kronl = _c3.vec_kronl
class fiber_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, fiber_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, fiber_list, name)
    __repr__ = _swig_repr
    __swig_setmethods__["index"] = _c3.fiber_list_index_set
    __swig_getmethods__["index"] = _c3.fiber_list_index_get
    if _newclass:
        index = _swig_property(_c3.fiber_list_index_get, _c3.fiber_list_index_set)
    __swig_setmethods__["vals"] = _c3.fiber_list_vals_set
    __swig_getmethods__["vals"] = _c3.fiber_list_vals_get
    if _newclass:
        vals = _swig_property(_c3.fiber_list_vals_get, _c3.fiber_list_vals_set)
    __swig_setmethods__["next"] = _c3.fiber_list_next_set
    __swig_getmethods__["next"] = _c3.fiber_list_next_get
    if _newclass:
        next = _swig_property(_c3.fiber_list_next_get, _c3.fiber_list_next_set)

    def __init__(self):
        this = _c3.new_fiber_list()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_fiber_list
    __del__ = lambda self: None
fiber_list_swigregister = _c3.fiber_list_swigregister
fiber_list_swigregister(fiber_list)

class fiber_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, fiber_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, fiber_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nfibers"] = _c3.fiber_info_nfibers_set
    __swig_getmethods__["nfibers"] = _c3.fiber_info_nfibers_get
    if _newclass:
        nfibers = _swig_property(_c3.fiber_info_nfibers_get, _c3.fiber_info_nfibers_set)
    __swig_setmethods__["head"] = _c3.fiber_info_head_set
    __swig_getmethods__["head"] = _c3.fiber_info_head_get
    if _newclass:
        head = _swig_property(_c3.fiber_info_head_get, _c3.fiber_info_head_set)

    def __init__(self):
        this = _c3.new_fiber_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_fiber_info
    __del__ = lambda self: None
fiber_info_swigregister = _c3.fiber_info_swigregister
fiber_info_swigregister(fiber_info)


def AddFiber(arg1: 'struct fiber_list **', arg2: 'size_t', arg3: 'double *', arg4: 'size_t') -> "void":
    return _c3.AddFiber(arg1, arg2, arg3, arg4)
AddFiber = _c3.AddFiber

def IndexExists(arg1: 'fiber_list', arg2: 'size_t') -> "int":
    return _c3.IndexExists(arg1, arg2)
IndexExists = _c3.IndexExists

def getIndex(arg1: 'fiber_list', arg2: 'size_t') -> "double *":
    return _c3.getIndex(arg1, arg2)
getIndex = _c3.getIndex

def DeleteFiberList(arg1: 'struct fiber_list **') -> "void":
    return _c3.DeleteFiberList(arg1)
DeleteFiberList = _c3.DeleteFiberList
class sk_decomp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sk_decomp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sk_decomp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["n"] = _c3.sk_decomp_n_set
    __swig_getmethods__["n"] = _c3.sk_decomp_n_get
    if _newclass:
        n = _swig_property(_c3.sk_decomp_n_get, _c3.sk_decomp_n_set)
    __swig_setmethods__["m"] = _c3.sk_decomp_m_set
    __swig_getmethods__["m"] = _c3.sk_decomp_m_get
    if _newclass:
        m = _swig_property(_c3.sk_decomp_m_get, _c3.sk_decomp_m_set)
    __swig_setmethods__["rank"] = _c3.sk_decomp_rank_set
    __swig_getmethods__["rank"] = _c3.sk_decomp_rank_get
    if _newclass:
        rank = _swig_property(_c3.sk_decomp_rank_get, _c3.sk_decomp_rank_set)
    __swig_setmethods__["rows_kept"] = _c3.sk_decomp_rows_kept_set
    __swig_getmethods__["rows_kept"] = _c3.sk_decomp_rows_kept_get
    if _newclass:
        rows_kept = _swig_property(_c3.sk_decomp_rows_kept_get, _c3.sk_decomp_rows_kept_set)
    __swig_setmethods__["cols_kept"] = _c3.sk_decomp_cols_kept_set
    __swig_getmethods__["cols_kept"] = _c3.sk_decomp_cols_kept_get
    if _newclass:
        cols_kept = _swig_property(_c3.sk_decomp_cols_kept_get, _c3.sk_decomp_cols_kept_set)
    __swig_setmethods__["cross_rank"] = _c3.sk_decomp_cross_rank_set
    __swig_getmethods__["cross_rank"] = _c3.sk_decomp_cross_rank_get
    if _newclass:
        cross_rank = _swig_property(_c3.sk_decomp_cross_rank_get, _c3.sk_decomp_cross_rank_set)
    __swig_setmethods__["cross_inv"] = _c3.sk_decomp_cross_inv_set
    __swig_getmethods__["cross_inv"] = _c3.sk_decomp_cross_inv_get
    if _newclass:
        cross_inv = _swig_property(_c3.sk_decomp_cross_inv_get, _c3.sk_decomp_cross_inv_set)
    __swig_setmethods__["row_vals"] = _c3.sk_decomp_row_vals_set
    __swig_getmethods__["row_vals"] = _c3.sk_decomp_row_vals_get
    if _newclass:
        row_vals = _swig_property(_c3.sk_decomp_row_vals_get, _c3.sk_decomp_row_vals_set)
    __swig_setmethods__["col_vals"] = _c3.sk_decomp_col_vals_set
    __swig_getmethods__["col_vals"] = _c3.sk_decomp_col_vals_get
    if _newclass:
        col_vals = _swig_property(_c3.sk_decomp_col_vals_get, _c3.sk_decomp_col_vals_set)
    __swig_setmethods__["success"] = _c3.sk_decomp_success_set
    __swig_getmethods__["success"] = _c3.sk_decomp_success_get
    if _newclass:
        success = _swig_property(_c3.sk_decomp_success_get, _c3.sk_decomp_success_set)

    def __init__(self):
        this = _c3.new_sk_decomp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_sk_decomp
    __del__ = lambda self: None
sk_decomp_swigregister = _c3.sk_decomp_swigregister
sk_decomp_swigregister(sk_decomp)


def init_skf(arg1: 'struct sk_decomp **', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t') -> "void":
    return _c3.init_skf(arg1, arg2, arg3, arg4)
init_skf = _c3.init_skf

def sk_decomp_to_full(arg1: 'sk_decomp', arg2: 'double *') -> "void":
    return _c3.sk_decomp_to_full(arg1, arg2)
sk_decomp_to_full = _c3.sk_decomp_to_full

def free_skf(arg1: 'struct sk_decomp **') -> "void":
    return _c3.free_skf(arg1)
free_skf = _c3.free_skf

def maxvol_rhs(arg1: 'double const *', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t *', arg5: 'double *') -> "int":
    return _c3.maxvol_rhs(arg1, arg2, arg3, arg4, arg5)
maxvol_rhs = _c3.maxvol_rhs

def skeleton(arg1: 'double *', arg2: 'size_t', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t *', arg6: 'size_t *', arg7: 'double') -> "int":
    return _c3.skeleton(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
skeleton = _c3.skeleton

def skeleton_func(A: 'double (*)(int,int,int,void *)', arg2: 'void *', arg3: 'size_t', arg4: 'size_t', arg5: 'size_t', arg6: 'size_t *', arg7: 'size_t *', arg8: 'double') -> "int":
    return _c3.skeleton_func(A, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
skeleton_func = _c3.skeleton_func

def skeleton_func2(Ap: 'int (*)(double *,double,size_t,size_t,double *,void *)', arg2: 'void *', arg3: 'struct sk_decomp **', arg4: 'double *', arg5: 'double *', arg6: 'double') -> "int":
    return _c3.skeleton_func2(Ap, arg2, arg3, arg4, arg5, arg6)
skeleton_func2 = _c3.skeleton_func2

def linear_ls(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'double *', arg5: 'double *') -> "void":
    return _c3.linear_ls(arg1, arg2, arg3, arg4, arg5)
linear_ls = _c3.linear_ls
class mat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nrows"] = _c3.mat_nrows_set
    __swig_getmethods__["nrows"] = _c3.mat_nrows_get
    if _newclass:
        nrows = _swig_property(_c3.mat_nrows_get, _c3.mat_nrows_set)
    __swig_setmethods__["ncols"] = _c3.mat_ncols_set
    __swig_getmethods__["ncols"] = _c3.mat_ncols_get
    if _newclass:
        ncols = _swig_property(_c3.mat_ncols_get, _c3.mat_ncols_set)
    __swig_setmethods__["vals"] = _c3.mat_vals_set
    __swig_getmethods__["vals"] = _c3.mat_vals_get
    if _newclass:
        vals = _swig_property(_c3.mat_vals_get, _c3.mat_vals_set)

    def __init__(self):
        this = _c3.new_mat()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_mat
    __del__ = lambda self: None
mat_swigregister = _c3.mat_swigregister
mat_swigregister(mat)


def v2m(arg1: 'size_t', arg2: 'double *', arg3: 'int') -> "struct mat *":
    return _c3.v2m(arg1, arg2, arg3)
v2m = _c3.v2m

def diagv2m(arg1: 'size_t', arg2: 'double *') -> "struct mat *":
    return _c3.diagv2m(arg1, arg2)
diagv2m = _c3.diagv2m

def horizcat(arg1: 'mat', arg2: 'mat') -> "struct mat *":
    return _c3.horizcat(arg1, arg2)
horizcat = _c3.horizcat

def block_diag(arg1: 'struct mat const **', arg2: 'size_t') -> "struct mat *":
    return _c3.block_diag(arg1, arg2)
block_diag = _c3.block_diag

def freemat(arg1: 'mat') -> "void":
    return _c3.freemat(arg1)
freemat = _c3.freemat

def printmat(arg1: 'mat') -> "void":
    return _c3.printmat(arg1)
printmat = _c3.printmat

def mat_ones(arg1: 'mat', arg2: 'size_t', arg3: 'size_t') -> "void":
    return _c3.mat_ones(arg1, arg2, arg3)
mat_ones = _c3.mat_ones
BACKTRACK = _c3.BACKTRACK
STRONGWOLFE = _c3.STRONGWOLFE
WEAKWOLFE = _c3.WEAKWOLFE
BFGS = _c3.BFGS
LBFGS = _c3.LBFGS
BATCHGRAD = _c3.BATCHGRAD
BRUTEFORCE = _c3.BRUTEFORCE
SGD = _c3.SGD
C3OPT_LS_PARAM_INVALID = _c3.C3OPT_LS_PARAM_INVALID
C3OPT_LS_MAXITER_REACHED = _c3.C3OPT_LS_MAXITER_REACHED
C3OPT_X_BOUND_VIOLATED = _c3.C3OPT_X_BOUND_VIOLATED
C3OPT_MAXITER_REACHED = _c3.C3OPT_MAXITER_REACHED
C3OPT_SUCCESS = _c3.C3OPT_SUCCESS
C3OPT_FTOL_REACHED = _c3.C3OPT_FTOL_REACHED
C3OPT_XTOL_REACHED = _c3.C3OPT_XTOL_REACHED
C3OPT_GTOL_REACHED = _c3.C3OPT_GTOL_REACHED

def c3opt_create(arg1: 'enum c3opt_alg') -> "struct c3Opt *":
    return _c3.c3opt_create(arg1)
c3opt_create = _c3.c3opt_create

def c3opt_set_nvars(arg1: 'struct c3Opt *', arg2: 'size_t') -> "void":
    return _c3.c3opt_set_nvars(arg1, arg2)
c3opt_set_nvars = _c3.c3opt_set_nvars

def c3opt_alloc(arg1: 'enum c3opt_alg', arg2: 'size_t') -> "struct c3Opt *":
    return _c3.c3opt_alloc(arg1, arg2)
c3opt_alloc = _c3.c3opt_alloc

def c3opt_copy(arg1: 'struct c3Opt *') -> "struct c3Opt *":
    return _c3.c3opt_copy(arg1)
c3opt_copy = _c3.c3opt_copy

def c3opt_free(arg1: 'struct c3Opt *') -> "void":
    return _c3.c3opt_free(arg1)
c3opt_free = _c3.c3opt_free

def c3opt_set_sgd_learn_rate(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_set_sgd_learn_rate(arg1, arg2)
c3opt_set_sgd_learn_rate = _c3.c3opt_set_sgd_learn_rate

def c3opt_set_sgd_nsamples(arg1: 'struct c3Opt *', arg2: 'size_t') -> "void":
    return _c3.c3opt_set_sgd_nsamples(arg1, arg2)
c3opt_set_sgd_nsamples = _c3.c3opt_set_sgd_nsamples

def c3opt_get_sgd_nsamples(arg1: 'struct c3Opt const *') -> "size_t":
    return _c3.c3opt_get_sgd_nsamples(arg1)
c3opt_get_sgd_nsamples = _c3.c3opt_get_sgd_nsamples

def c3opt_set_nvectors_store(arg1: 'struct c3Opt *', arg2: 'size_t') -> "void":
    return _c3.c3opt_set_nvectors_store(arg1, arg2)
c3opt_set_nvectors_store = _c3.c3opt_set_nvectors_store

def c3opt_get_nvectors_store(arg1: 'struct c3Opt const *') -> "size_t":
    return _c3.c3opt_get_nvectors_store(arg1)
c3opt_get_nvectors_store = _c3.c3opt_get_nvectors_store

def c3opt_set_lbfgs_scale(arg1: 'struct c3Opt *', arg2: 'int') -> "void":
    return _c3.c3opt_set_lbfgs_scale(arg1, arg2)
c3opt_set_lbfgs_scale = _c3.c3opt_set_lbfgs_scale

def c3opt_get_lbfgs_scale(arg1: 'struct c3Opt *') -> "int":
    return _c3.c3opt_get_lbfgs_scale(arg1)
c3opt_get_lbfgs_scale = _c3.c3opt_get_lbfgs_scale

def c3opt_is_bruteforce(arg1: 'struct c3Opt const *') -> "int":
    return _c3.c3opt_is_bruteforce(arg1)
c3opt_is_bruteforce = _c3.c3opt_is_bruteforce

def c3opt_is_sgd(arg1: 'struct c3Opt const *') -> "int":
    return _c3.c3opt_is_sgd(arg1)
c3opt_is_sgd = _c3.c3opt_is_sgd

def c3opt_add_lb(arg1: 'struct c3Opt *', arg2: 'double *') -> "void":
    return _c3.c3opt_add_lb(arg1, arg2)
c3opt_add_lb = _c3.c3opt_add_lb

def c3opt_add_ub(arg1: 'struct c3Opt *', arg2: 'double *') -> "void":
    return _c3.c3opt_add_ub(arg1, arg2)
c3opt_add_ub = _c3.c3opt_add_ub

def c3opt_add_objective(arg1: 'struct c3Opt *', arg2: 'double (*)(size_t,double const *,double *,void *)', arg3: 'void *') -> "void":
    return _c3.c3opt_add_objective(arg1, arg2, arg3)
c3opt_add_objective = _c3.c3opt_add_objective

def c3opt_add_objective_stoch(arg1: 'struct c3Opt *', arg2: 'double (*)(size_t,size_t,double const *,double *,void *)', arg3: 'void *') -> "void":
    return _c3.c3opt_add_objective_stoch(arg1, arg2, arg3)
c3opt_add_objective_stoch = _c3.c3opt_add_objective_stoch

def c3opt_set_verbose(arg1: 'struct c3Opt *', arg2: 'int') -> "void":
    return _c3.c3opt_set_verbose(arg1, arg2)
c3opt_set_verbose = _c3.c3opt_set_verbose

def c3opt_set_maxiter(arg1: 'struct c3Opt *', arg2: 'size_t') -> "void":
    return _c3.c3opt_set_maxiter(arg1, arg2)
c3opt_set_maxiter = _c3.c3opt_set_maxiter

def c3opt_get_maxiter(arg1: 'struct c3Opt const *') -> "size_t":
    return _c3.c3opt_get_maxiter(arg1)
c3opt_get_maxiter = _c3.c3opt_get_maxiter

def c3opt_set_absxtol(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_set_absxtol(arg1, arg2)
c3opt_set_absxtol = _c3.c3opt_set_absxtol

def c3opt_get_niters(arg1: 'struct c3Opt *') -> "size_t":
    return _c3.c3opt_get_niters(arg1)
c3opt_get_niters = _c3.c3opt_get_niters

def c3opt_get_stored_function(arg1: 'struct c3Opt const *', arg2: 'size_t') -> "double":
    return _c3.c3opt_get_stored_function(arg1, arg2)
c3opt_get_stored_function = _c3.c3opt_get_stored_function

def c3opt_get_nevals(arg1: 'struct c3Opt *') -> "size_t":
    return _c3.c3opt_get_nevals(arg1)
c3opt_get_nevals = _c3.c3opt_get_nevals

def c3opt_get_ngvals(arg1: 'struct c3Opt *') -> "size_t":
    return _c3.c3opt_get_ngvals(arg1)
c3opt_get_ngvals = _c3.c3opt_get_ngvals

def c3opt_set_relftol(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_set_relftol(arg1, arg2)
c3opt_set_relftol = _c3.c3opt_set_relftol

def c3opt_set_gtol(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_set_gtol(arg1, arg2)
c3opt_set_gtol = _c3.c3opt_set_gtol

def c3opt_set_storage_options(arg1: 'struct c3Opt *', arg2: 'int', arg3: 'int', arg4: 'int') -> "void":
    return _c3.c3opt_set_storage_options(arg1, arg2, arg3, arg4)
c3opt_set_storage_options = _c3.c3opt_set_storage_options

def c3opt_get_store_func(arg1: 'struct c3Opt const *') -> "int":
    return _c3.c3opt_get_store_func(arg1)
c3opt_get_store_func = _c3.c3opt_get_store_func

def c3opt_print_stored_values(arg1: 'struct c3Opt *', arg2: 'FILE *', arg3: 'int', arg4: 'int') -> "void":
    return _c3.c3opt_print_stored_values(arg1, arg2, arg3, arg4)
c3opt_print_stored_values = _c3.c3opt_print_stored_values

def c3opt_ls_get_initial(arg1: 'struct c3Opt const *') -> "int":
    return _c3.c3opt_ls_get_initial(arg1)
c3opt_ls_get_initial = _c3.c3opt_ls_get_initial

def c3opt_ls_set_alg(arg1: 'struct c3Opt *', arg2: 'enum c3opt_ls_alg') -> "void":
    return _c3.c3opt_ls_set_alg(arg1, arg2)
c3opt_ls_set_alg = _c3.c3opt_ls_set_alg

def c3opt_ls_get_alg(arg1: 'struct c3Opt const *') -> "enum c3opt_ls_alg":
    return _c3.c3opt_ls_get_alg(arg1)
c3opt_ls_get_alg = _c3.c3opt_ls_get_alg

def c3opt_ls_set_alpha(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_ls_set_alpha(arg1, arg2)
c3opt_ls_set_alpha = _c3.c3opt_ls_set_alpha

def c3opt_ls_get_alpha(arg1: 'struct c3Opt *') -> "double":
    return _c3.c3opt_ls_get_alpha(arg1)
c3opt_ls_get_alpha = _c3.c3opt_ls_get_alpha

def c3opt_ls_set_beta(arg1: 'struct c3Opt *', arg2: 'double') -> "void":
    return _c3.c3opt_ls_set_beta(arg1, arg2)
c3opt_ls_set_beta = _c3.c3opt_ls_set_beta

def c3opt_ls_get_beta(arg1: 'struct c3Opt *') -> "double":
    return _c3.c3opt_ls_get_beta(arg1)
c3opt_ls_get_beta = _c3.c3opt_ls_get_beta

def c3opt_ls_set_maxiter(arg1: 'struct c3Opt *', arg2: 'size_t') -> "void":
    return _c3.c3opt_ls_set_maxiter(arg1, arg2)
c3opt_ls_set_maxiter = _c3.c3opt_ls_set_maxiter

def c3opt_ls_get_maxiter(arg1: 'struct c3Opt *') -> "size_t":
    return _c3.c3opt_ls_get_maxiter(arg1)
c3opt_ls_get_maxiter = _c3.c3opt_ls_get_maxiter

def c3opt_ls_wolfe_bisect(arg1: 'struct c3Opt *', arg2: 'double *', arg3: 'double', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *', arg8: 'int *') -> "double":
    return _c3.c3opt_ls_wolfe_bisect(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
c3opt_ls_wolfe_bisect = _c3.c3opt_ls_wolfe_bisect

def c3opt_ls_strong_wolfe(arg1: 'struct c3Opt *', arg2: 'double *', arg3: 'double', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *', arg8: 'int *') -> "double":
    return _c3.c3opt_ls_strong_wolfe(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
c3opt_ls_strong_wolfe = _c3.c3opt_ls_strong_wolfe

def c3opt_set_brute_force_vals(arg1: 'struct c3Opt *', arg2: 'size_t', arg3: 'double *') -> "void":
    return _c3.c3opt_set_brute_force_vals(arg1, arg2, arg3)
c3opt_set_brute_force_vals = _c3.c3opt_set_brute_force_vals

def c3opt_minimize(arg1: 'struct c3Opt *', arg2: 'double *', arg3: 'double *') -> "int":
    return _c3.c3opt_minimize(arg1, arg2, arg3)
c3opt_minimize = _c3.c3opt_minimize

def c3opt_get_lb(arg1: 'struct c3Opt *') -> "double *":
    return _c3.c3opt_get_lb(arg1)
c3opt_get_lb = _c3.c3opt_get_lb

def c3opt_get_ub(arg1: 'struct c3Opt *') -> "double *":
    return _c3.c3opt_get_ub(arg1)
c3opt_get_ub = _c3.c3opt_get_ub

def c3opt_eval(arg1: 'struct c3Opt *', arg2: 'double const *', arg3: 'double *') -> "double":
    return _c3.c3opt_eval(arg1, arg2, arg3)
c3opt_eval = _c3.c3opt_eval

def c3opt_eval_stoch(arg1: 'struct c3Opt *', arg2: 'size_t', arg3: 'double const *', arg4: 'double *') -> "double":
    return _c3.c3opt_eval_stoch(arg1, arg2, arg3, arg4)
c3opt_eval_stoch = _c3.c3opt_eval_stoch

def c3opt_check_deriv(arg1: 'struct c3Opt *', arg2: 'double const *', arg3: 'double') -> "double":
    return _c3.c3opt_check_deriv(arg1, arg2, arg3)
c3opt_check_deriv = _c3.c3opt_check_deriv

def c3opt_check_deriv_each(arg1: 'struct c3Opt *', arg2: 'double const *', arg3: 'double', arg4: 'double *') -> "double":
    return _c3.c3opt_check_deriv_each(arg1, arg2, arg3, arg4)
c3opt_check_deriv_each = _c3.c3opt_check_deriv_each

def c3opt_lbfgs_list_alloc(arg1: 'size_t', arg2: 'size_t') -> "struct c3opt_lbfgs_list *":
    return _c3.c3opt_lbfgs_list_alloc(arg1, arg2)
c3opt_lbfgs_list_alloc = _c3.c3opt_lbfgs_list_alloc

def c3opt_lbfgs_list_insert(arg1: 'struct c3opt_lbfgs_list *', arg2: 'size_t', arg3: 'double const *', arg4: 'double const *', arg5: 'double const *', arg6: 'double const *') -> "void":
    return _c3.c3opt_lbfgs_list_insert(arg1, arg2, arg3, arg4, arg5, arg6)
c3opt_lbfgs_list_insert = _c3.c3opt_lbfgs_list_insert

def c3opt_lbfgs_reset_step(arg1: 'struct c3opt_lbfgs_list *') -> "void":
    return _c3.c3opt_lbfgs_reset_step(arg1)
c3opt_lbfgs_reset_step = _c3.c3opt_lbfgs_reset_step

def c3opt_lbfgs_list_step(arg1: 'struct c3opt_lbfgs_list *', arg2: 'size_t *', arg3: 'double **', arg4: 'double **', arg5: 'double *') -> "void":
    return _c3.c3opt_lbfgs_list_step(arg1, arg2, arg3, arg4, arg5)
c3opt_lbfgs_list_step = _c3.c3opt_lbfgs_list_step

def c3opt_lbfgs_list_step_back(arg1: 'struct c3opt_lbfgs_list *', arg2: 'size_t *', arg3: 'double **', arg4: 'double **', arg5: 'double *') -> "void":
    return _c3.c3opt_lbfgs_list_step_back(arg1, arg2, arg3, arg4, arg5)
c3opt_lbfgs_list_step_back = _c3.c3opt_lbfgs_list_step_back

def c3opt_lbfgs_list_print(arg1: 'struct c3opt_lbfgs_list *', arg2: 'FILE *', arg3: 'int', arg4: 'int') -> "void":
    return _c3.c3opt_lbfgs_list_print(arg1, arg2, arg3, arg4)
c3opt_lbfgs_list_print = _c3.c3opt_lbfgs_list_print

def c3opt_lbfgs_list_free(arg1: 'struct c3opt_lbfgs_list *') -> "void":
    return _c3.c3opt_lbfgs_list_free(arg1)
c3opt_lbfgs_list_free = _c3.c3opt_lbfgs_list_free

def newton(arg1: 'double **', arg2: 'size_t', arg3: 'double', arg4: 'double', arg5: 'double *(*)(double *,void *)', arg6: 'double *(*)(double *,void *)', arg7: 'void *') -> "void":
    return _c3.newton(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
newton = _c3.newton

def backtrack_line_search(arg1: 'size_t', arg2: 'double *', arg3: 'double', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *', arg8: 'double', arg9: 'double', arg10: 'double (*)(double *,void *)', arg11: 'void *', arg12: 'size_t', arg13: 'int *') -> "double":
    return _c3.backtrack_line_search(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
backtrack_line_search = _c3.backtrack_line_search

def backtrack_line_search_bc(arg1: 'size_t', arg2: 'double *', arg3: 'double *', arg4: 'double *', arg5: 'double', arg6: 'double *', arg7: 'double *', arg8: 'double *', arg9: 'double *', arg10: 'double', arg11: 'double', arg12: 'double (*)(double *,void *)', arg13: 'void *', arg14: 'size_t', arg15: 'int *') -> "double":
    return _c3.backtrack_line_search_bc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15)
backtrack_line_search_bc = _c3.backtrack_line_search_bc

def gradient_descent(arg1: 'size_t', arg2: 'double *', arg3: 'double *', arg4: 'double *', arg5: 'double *', arg6: 'double (*)(double *,void *)', arg7: 'void *', arg8: 'int (*)(double *,double *,void *)', arg9: 'void *', arg10: 'double', arg11: 'size_t', arg12: 'size_t', arg13: 'double', arg14: 'double', arg15: 'int') -> "int":
    return _c3.gradient_descent(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15)
gradient_descent = _c3.gradient_descent

def box_pg_descent(arg1: 'size_t', arg2: 'double *', arg3: 'double *', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *', arg8: 'double (*)(double *,void *)', arg9: 'void *', g: 'int (*)(double *,double *,void *)', arg11: 'void *', arg12: 'double', arg13: 'size_t', arg14: 'size_t', arg15: 'double', arg16: 'double', arg17: 'int') -> "int":
    return _c3.box_pg_descent(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, g, arg11, arg12, arg13, arg14, arg15, arg16, arg17)
box_pg_descent = _c3.box_pg_descent

def box_damp_newton(arg1: 'size_t', arg2: 'double *', arg3: 'double *', arg4: 'double *', arg5: 'double *', arg6: 'double *', arg7: 'double *', arg8: 'double *', arg9: 'double (*)(double *,void *)', arg10: 'void *', arg11: 'int (*)(double *,double *,void *)', arg12: 'void *', arg13: 'int (*)(double *,double *,void *)', arg14: 'void *', arg15: 'double', arg16: 'size_t', arg17: 'size_t', arg18: 'double', arg19: 'double', arg20: 'int') -> "int":
    return _c3.box_damp_newton(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
box_damp_newton = _c3.box_damp_newton

def box_damp_bfgs(d: 'size_t', lb: 'double *', ub: 'double *', x: 'double *', fval: 'double *', grad: 'double *', invhess: 'double *', space: 'double *', f: 'double (*)(double *,void *)', fargs: 'void *', g: 'int (*)(double *,double *,void *)', tol: 'double', maxiter: 'size_t', maxsubiter: 'size_t', alpha: 'double', beta: 'double', verbose: 'int') -> "int":
    return _c3.box_damp_bfgs(d, lb, ub, x, fval, grad, invhess, space, f, fargs, g, tol, maxiter, maxsubiter, alpha, beta, verbose)
box_damp_bfgs = _c3.box_damp_bfgs

def c3_sobol_sensitivity_calculate(arg1: 'FunctionTrain', arg2: 'size_t') -> "struct C3SobolSensitivity *":
    return _c3.c3_sobol_sensitivity_calculate(arg1, arg2)
c3_sobol_sensitivity_calculate = _c3.c3_sobol_sensitivity_calculate

def c3_sobol_sensitivity_free(arg1: 'struct C3SobolSensitivity *') -> "void":
    return _c3.c3_sobol_sensitivity_free(arg1)
c3_sobol_sensitivity_free = _c3.c3_sobol_sensitivity_free

def c3_sobol_sensitivity_get_interaction(arg1: 'struct C3SobolSensitivity const *', leni: 'size_t') -> "double":
    return _c3.c3_sobol_sensitivity_get_interaction(arg1, leni)
c3_sobol_sensitivity_get_interaction = _c3.c3_sobol_sensitivity_get_interaction

def c3_sobol_sensitivity_get_total(arg1: 'struct C3SobolSensitivity const *', arg2: 'size_t') -> "double":
    return _c3.c3_sobol_sensitivity_get_total(arg1, arg2)
c3_sobol_sensitivity_get_total = _c3.c3_sobol_sensitivity_get_total

def c3_sobol_sensitivity_get_main(arg1: 'struct C3SobolSensitivity const *', arg2: 'size_t') -> "double":
    return _c3.c3_sobol_sensitivity_get_main(arg1, arg2)
c3_sobol_sensitivity_get_main = _c3.c3_sobol_sensitivity_get_main

def c3_sobol_sensitivity_get_variance(arg1: 'struct C3SobolSensitivity const *') -> "double":
    return _c3.c3_sobol_sensitivity_get_variance(arg1)
c3_sobol_sensitivity_get_variance = _c3.c3_sobol_sensitivity_get_variance

def c3_sobol_sensitivity_print(arg1: 'struct C3SobolSensitivity const *') -> "void":
    return _c3.c3_sobol_sensitivity_print(arg1)
c3_sobol_sensitivity_print = _c3.c3_sobol_sensitivity_print

def c3_sobol_sensitivity_apply_external(arg1: 'struct C3SobolSensitivity const *', arg2: 'void (*)(double,size_t,size_t *,void *)', arg3: 'void *') -> "void":
    return _c3.c3_sobol_sensitivity_apply_external(arg1, arg2, arg3)
c3_sobol_sensitivity_apply_external = _c3.c3_sobol_sensitivity_apply_external
LT = _c3.LT
SYMMETRIC = _c3.SYMMETRIC
GEN = _c3.GEN
GAUSSIAN = _c3.GAUSSIAN
GENERAL = _c3.GENERAL
GAUSSIAN_LIKE = _c3.GAUSSIAN_LIKE
POISSON_LIKE = _c3.POISSON_LIKE
GENERIC_LIKE = _c3.GENERIC_LIKE
class LinearTransform(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearTransform, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinearTransform, name)
    __repr__ = _swig_repr
    __swig_setmethods__["A"] = _c3.LinearTransform_A_set
    __swig_getmethods__["A"] = _c3.LinearTransform_A_get
    if _newclass:
        A = _swig_property(_c3.LinearTransform_A_get, _c3.LinearTransform_A_set)
    __swig_setmethods__["b"] = _c3.LinearTransform_b_set
    __swig_getmethods__["b"] = _c3.LinearTransform_b_get
    if _newclass:
        b = _swig_property(_c3.LinearTransform_b_get, _c3.LinearTransform_b_set)
    __swig_setmethods__["det"] = _c3.LinearTransform_det_set
    __swig_getmethods__["det"] = _c3.LinearTransform_det_get
    if _newclass:
        det = _swig_property(_c3.LinearTransform_det_get, _c3.LinearTransform_det_set)
    __swig_setmethods__["Ainv"] = _c3.LinearTransform_Ainv_set
    __swig_getmethods__["Ainv"] = _c3.LinearTransform_Ainv_get
    if _newclass:
        Ainv = _swig_property(_c3.LinearTransform_Ainv_get, _c3.LinearTransform_Ainv_set)
    __swig_setmethods__["binv"] = _c3.LinearTransform_binv_set
    __swig_getmethods__["binv"] = _c3.LinearTransform_binv_get
    if _newclass:
        binv = _swig_property(_c3.LinearTransform_binv_get, _c3.LinearTransform_binv_set)
    __swig_setmethods__["detinv"] = _c3.LinearTransform_detinv_set
    __swig_getmethods__["detinv"] = _c3.LinearTransform_detinv_get
    if _newclass:
        detinv = _swig_property(_c3.LinearTransform_detinv_get, _c3.LinearTransform_detinv_set)
    __swig_setmethods__["dimin"] = _c3.LinearTransform_dimin_set
    __swig_getmethods__["dimin"] = _c3.LinearTransform_dimin_get
    if _newclass:
        dimin = _swig_property(_c3.LinearTransform_dimin_get, _c3.LinearTransform_dimin_set)
    __swig_setmethods__["dimout"] = _c3.LinearTransform_dimout_set
    __swig_getmethods__["dimout"] = _c3.LinearTransform_dimout_get
    if _newclass:
        dimout = _swig_property(_c3.LinearTransform_dimout_get, _c3.LinearTransform_dimout_set)
    __swig_setmethods__["mt"] = _c3.LinearTransform_mt_set
    __swig_getmethods__["mt"] = _c3.LinearTransform_mt_get
    if _newclass:
        mt = _swig_property(_c3.LinearTransform_mt_get, _c3.LinearTransform_mt_set)
    __swig_setmethods__["mti"] = _c3.LinearTransform_mti_set
    __swig_getmethods__["mti"] = _c3.LinearTransform_mti_get
    if _newclass:
        mti = _swig_property(_c3.LinearTransform_mti_get, _c3.LinearTransform_mti_set)

    def __init__(self):
        this = _c3.new_LinearTransform()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_LinearTransform
    __del__ = lambda self: None
LinearTransform_swigregister = _c3.LinearTransform_swigregister
LinearTransform_swigregister(LinearTransform)

class ProbabilityDensity(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProbabilityDensity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProbabilityDensity, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pdf"] = _c3.ProbabilityDensity_pdf_set
    __swig_getmethods__["pdf"] = _c3.ProbabilityDensity_pdf_get
    if _newclass:
        pdf = _swig_property(_c3.ProbabilityDensity_pdf_get, _c3.ProbabilityDensity_pdf_set)
    __swig_setmethods__["lt"] = _c3.ProbabilityDensity_lt_set
    __swig_getmethods__["lt"] = _c3.ProbabilityDensity_lt_get
    if _newclass:
        lt = _swig_property(_c3.ProbabilityDensity_lt_get, _c3.ProbabilityDensity_lt_set)
    __swig_setmethods__["transform"] = _c3.ProbabilityDensity_transform_set
    __swig_getmethods__["transform"] = _c3.ProbabilityDensity_transform_get
    if _newclass:
        transform = _swig_property(_c3.ProbabilityDensity_transform_get, _c3.ProbabilityDensity_transform_set)
    __swig_setmethods__["type"] = _c3.ProbabilityDensity_type_set
    __swig_getmethods__["type"] = _c3.ProbabilityDensity_type_get
    if _newclass:
        type = _swig_property(_c3.ProbabilityDensity_type_get, _c3.ProbabilityDensity_type_set)
    __swig_setmethods__["extra"] = _c3.ProbabilityDensity_extra_set
    __swig_getmethods__["extra"] = _c3.ProbabilityDensity_extra_get
    if _newclass:
        extra = _swig_property(_c3.ProbabilityDensity_extra_get, _c3.ProbabilityDensity_extra_set)

    def __init__(self):
        this = _c3.new_ProbabilityDensity()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_ProbabilityDensity
    __del__ = lambda self: None
ProbabilityDensity_swigregister = _c3.ProbabilityDensity_swigregister
ProbabilityDensity_swigregister(ProbabilityDensity)


def linear_transform_alloc(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'double *', arg5: 'double') -> "struct LinearTransform *":
    return _c3.linear_transform_alloc(arg1, arg2, arg3, arg4, arg5)
linear_transform_alloc = _c3.linear_transform_alloc

def linear_transform_copy(arg1: 'LinearTransform') -> "struct LinearTransform *":
    return _c3.linear_transform_copy(arg1)
linear_transform_copy = _c3.linear_transform_copy

def linear_transform_free(arg1: 'LinearTransform') -> "void":
    return _c3.linear_transform_free(arg1)
linear_transform_free = _c3.linear_transform_free

def linear_transform_apply(arg1: 'size_t', arg2: 'size_t', arg3: 'double *', arg4: 'double *', arg5: 'double *') -> "double *":
    return _c3.linear_transform_apply(arg1, arg2, arg3, arg4, arg5)
linear_transform_apply = _c3.linear_transform_apply

def linear_transform_invert(arg1: 'LinearTransform') -> "void":
    return _c3.linear_transform_invert(arg1)
linear_transform_invert = _c3.linear_transform_invert

def linear_transform_serialize(arg1: 'unsigned char *', arg2: 'LinearTransform', arg3: 'size_t *') -> "unsigned char *":
    return _c3.linear_transform_serialize(arg1, arg2, arg3)
linear_transform_serialize = _c3.linear_transform_serialize

def linear_transform_deserialize(arg1: 'unsigned char *', arg2: 'struct LinearTransform **') -> "unsigned char *":
    return _c3.linear_transform_deserialize(arg1, arg2)
linear_transform_deserialize = _c3.linear_transform_deserialize

def probability_density_alloc() -> "struct ProbabilityDensity *":
    return _c3.probability_density_alloc()
probability_density_alloc = _c3.probability_density_alloc

def probability_density_free(arg1: 'ProbabilityDensity') -> "void":
    return _c3.probability_density_free(arg1)
probability_density_free = _c3.probability_density_free

def probability_density_serialize(arg1: 'unsigned char *', arg2: 'ProbabilityDensity', arg3: 'size_t *') -> "unsigned char *":
    return _c3.probability_density_serialize(arg1, arg2, arg3)
probability_density_serialize = _c3.probability_density_serialize

def probability_density_deserialize(arg1: 'unsigned char *', arg2: 'struct ProbabilityDensity **') -> "unsigned char *":
    return _c3.probability_density_deserialize(arg1, arg2)
probability_density_deserialize = _c3.probability_density_deserialize

def probability_density_save(arg1: 'ProbabilityDensity', arg2: 'char *') -> "int":
    return _c3.probability_density_save(arg1, arg2)
probability_density_save = _c3.probability_density_save

def probability_density_load(arg1: 'char *') -> "struct ProbabilityDensity *":
    return _c3.probability_density_load(arg1)
probability_density_load = _c3.probability_density_load

def probability_density_eval(arg1: 'ProbabilityDensity', arg2: 'double *') -> "double":
    return _c3.probability_density_eval(arg1, arg2)
probability_density_eval = _c3.probability_density_eval

def probability_density_log_gradient_eval(arg1: 'ProbabilityDensity', arg2: 'double *') -> "double *":
    return _c3.probability_density_log_gradient_eval(arg1, arg2)
probability_density_log_gradient_eval = _c3.probability_density_log_gradient_eval

def probability_density_log_hessian_eval(arg1: 'ProbabilityDensity', arg2: 'double *') -> "double *":
    return _c3.probability_density_log_hessian_eval(arg1, arg2)
probability_density_log_hessian_eval = _c3.probability_density_log_hessian_eval

def probability_density_lb_base(arg1: 'ProbabilityDensity') -> "double *":
    return _c3.probability_density_lb_base(arg1)
probability_density_lb_base = _c3.probability_density_lb_base

def probability_density_ub_base(arg1: 'ProbabilityDensity') -> "double *":
    return _c3.probability_density_ub_base(arg1)
probability_density_ub_base = _c3.probability_density_ub_base

def probability_density_standard_normal(arg1: 'size_t') -> "struct ProbabilityDensity *":
    return _c3.probability_density_standard_normal(arg1)
probability_density_standard_normal = _c3.probability_density_standard_normal

def probability_density_mvn(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "struct ProbabilityDensity *":
    return _c3.probability_density_mvn(arg1, arg2, arg3)
probability_density_mvn = _c3.probability_density_mvn

def probability_density_sample(arg1: 'ProbabilityDensity') -> "double *":
    return _c3.probability_density_sample(arg1)
probability_density_sample = _c3.probability_density_sample

def probability_density_laplace(arg1: 'double (*)(size_t,double const *,double *,void *)', arg2: 'double *(*)(double *,void *)', arg3: 'void *', arg4: 'size_t', arg5: 'double *') -> "struct ProbabilityDensity *":
    return _c3.probability_density_laplace(arg1, arg2, arg3, arg4, arg5)
probability_density_laplace = _c3.probability_density_laplace
class Likelihood(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Likelihood, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Likelihood, name)
    __repr__ = _swig_repr
    __swig_setmethods__["datadim"] = _c3.Likelihood_datadim_set
    __swig_getmethods__["datadim"] = _c3.Likelihood_datadim_get
    if _newclass:
        datadim = _swig_property(_c3.Likelihood_datadim_get, _c3.Likelihood_datadim_set)
    __swig_setmethods__["paramdim"] = _c3.Likelihood_paramdim_set
    __swig_getmethods__["paramdim"] = _c3.Likelihood_paramdim_get
    if _newclass:
        paramdim = _swig_property(_c3.Likelihood_paramdim_get, _c3.Likelihood_paramdim_set)
    __swig_setmethods__["inputdim"] = _c3.Likelihood_inputdim_set
    __swig_getmethods__["inputdim"] = _c3.Likelihood_inputdim_get
    if _newclass:
        inputdim = _swig_property(_c3.Likelihood_inputdim_get, _c3.Likelihood_inputdim_set)
    __swig_setmethods__["type"] = _c3.Likelihood_type_set
    __swig_getmethods__["type"] = _c3.Likelihood_type_get
    if _newclass:
        type = _swig_property(_c3.Likelihood_type_get, _c3.Likelihood_type_set)
    __swig_setmethods__["like"] = _c3.Likelihood_like_set
    __swig_getmethods__["like"] = _c3.Likelihood_like_get
    if _newclass:
        like = _swig_property(_c3.Likelihood_like_get, _c3.Likelihood_like_set)
    __swig_setmethods__["loglike"] = _c3.Likelihood_loglike_set
    __swig_getmethods__["loglike"] = _c3.Likelihood_loglike_get
    if _newclass:
        loglike = _swig_property(_c3.Likelihood_loglike_get, _c3.Likelihood_loglike_set)
    __swig_setmethods__["logextra"] = _c3.Likelihood_logextra_set
    __swig_getmethods__["logextra"] = _c3.Likelihood_logextra_get
    if _newclass:
        logextra = _swig_property(_c3.Likelihood_logextra_get, _c3.Likelihood_logextra_set)

    def __init__(self):
        this = _c3.new_Likelihood()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_Likelihood
    __del__ = lambda self: None
Likelihood_swigregister = _c3.Likelihood_swigregister
Likelihood_swigregister(Likelihood)


def likelihood_free(arg1: 'Likelihood') -> "void":
    return _c3.likelihood_free(arg1)
likelihood_free = _c3.likelihood_free
class BayesRule(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BayesRule, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BayesRule, name)
    __repr__ = _swig_repr
    __swig_setmethods__["like"] = _c3.BayesRule_like_set
    __swig_getmethods__["like"] = _c3.BayesRule_like_get
    if _newclass:
        like = _swig_property(_c3.BayesRule_like_get, _c3.BayesRule_like_set)
    __swig_setmethods__["prior"] = _c3.BayesRule_prior_set
    __swig_getmethods__["prior"] = _c3.BayesRule_prior_get
    if _newclass:
        prior = _swig_property(_c3.BayesRule_prior_get, _c3.BayesRule_prior_set)

    def __init__(self):
        this = _c3.new_BayesRule()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _c3.delete_BayesRule
    __del__ = lambda self: None
BayesRule_swigregister = _c3.BayesRule_swigregister
BayesRule_swigregister(BayesRule)

C3_GAUSS_QUAD = _c3.C3_GAUSS_QUAD
C3_CC_QUAD = _c3.C3_CC_QUAD

def trap_w(arg1: 'size_t', arg2: 'double') -> "double *":
    return _c3.trap_w(arg1, arg2)
trap_w = _c3.trap_w

def simpson_w(arg1: 'size_t', arg2: 'double') -> "double *":
    return _c3.simpson_w(arg1, arg2)
simpson_w = _c3.simpson_w

def clenshaw_curtis(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "void":
    return _c3.clenshaw_curtis(arg1, arg2, arg3)
clenshaw_curtis = _c3.clenshaw_curtis

def rescale_cc(arg1: 'size_t', arg2: 'double *', arg3: 'double *', arg4: 'double', arg5: 'double') -> "void":
    return _c3.rescale_cc(arg1, arg2, arg3, arg4, arg5)
rescale_cc = _c3.rescale_cc

def fejer2(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "void":
    return _c3.fejer2(arg1, arg2, arg3)
fejer2 = _c3.fejer2

def cheb_gauss(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "int":
    return _c3.cheb_gauss(arg1, arg2, arg3)
cheb_gauss = _c3.cheb_gauss

def gauss_hermite(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "int":
    return _c3.gauss_hermite(arg1, arg2, arg3)
gauss_hermite = _c3.gauss_hermite

def gauss_legendre(arg1: 'size_t', arg2: 'double *', arg3: 'double *') -> "void":
    return _c3.gauss_legendre(arg1, arg2, arg3)
gauss_legendre = _c3.gauss_legendre
# This file is compatible with both classic and new-style classes.


