alglib4 0.0.0

data/ext/alglib/diffequations.h

@@ -0,0 +1,282 @@
+/*************************************************************************
+ALGLIB 4.04.0 (source code generated 2024-12-21)
+Copyright (c) Sergey Bochkanov (ALGLIB project).
+
+>>> SOURCE LICENSE >>>
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation (www.fsf.org); either version 2 of the 
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+A copy of the GNU General Public License is available at
+http://www.fsf.org/licensing/licenses
+>>> END OF LICENSE >>>
+*************************************************************************/
+#ifndef _diffequations_pkg_h
+#define _diffequations_pkg_h
+#include "ap.h"
+#include "alglibinternal.h"
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (DATATYPES)
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib_impl
+{
+#if defined(AE_COMPILE_ODESOLVER) || !defined(AE_PARTIAL_BUILD)
+typedef struct
+{
+    ae_int_t n;
+    ae_int_t m;
+    double xscale;
+    double h;
+    double eps;
+    ae_bool fraceps;
+    ae_vector yc;
+    ae_vector escale;
+    ae_vector xg;
+    ae_int_t solvertype;
+    ae_bool needdy;
+    double x;
+    ae_vector y;
+    ae_vector dy;
+    ae_matrix ytbl;
+    ae_int_t repterminationtype;
+    ae_int_t repnfev;
+    ae_vector yn;
+    ae_vector yns;
+    ae_vector rka;
+    ae_vector rkc;
+    ae_vector rkcs;
+    ae_matrix rkb;
+    ae_matrix rkk;
+    rcommstate rstate;
+} odesolverstate;
+typedef struct
+{
+    ae_int_t nfev;
+    ae_int_t terminationtype;
+} odesolverreport;
+#endif
+
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS C++ INTERFACE
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib
+{
+
+#if defined(AE_COMPILE_ODESOLVER) || !defined(AE_PARTIAL_BUILD)
+/*************************************************************************
+
+*************************************************************************/
+class _odesolverstate_owner
+{
+public:
+    _odesolverstate_owner();
+    _odesolverstate_owner(alglib_impl::odesolverstate *attach_to);
+    _odesolverstate_owner(const _odesolverstate_owner &rhs);
+    _odesolverstate_owner& operator=(const _odesolverstate_owner &rhs);
+    virtual ~_odesolverstate_owner();
+    alglib_impl::odesolverstate* c_ptr();
+    const alglib_impl::odesolverstate* c_ptr() const;
+protected:
+    alglib_impl::odesolverstate *p_struct;
+    bool is_attached;
+};
+class odesolverstate : public _odesolverstate_owner
+{
+public:
+    odesolverstate();
+    odesolverstate(alglib_impl::odesolverstate *attach_to);
+    odesolverstate(const odesolverstate &rhs);
+    odesolverstate& operator=(const odesolverstate &rhs);
+    virtual ~odesolverstate();
+    ae_bool &needdy;
+    real_1d_array y;
+    real_1d_array dy;
+    double &x;
+
+};
+
+
+/*************************************************************************
+
+*************************************************************************/
+class _odesolverreport_owner
+{
+public:
+    _odesolverreport_owner();
+    _odesolverreport_owner(alglib_impl::odesolverreport *attach_to);
+    _odesolverreport_owner(const _odesolverreport_owner &rhs);
+    _odesolverreport_owner& operator=(const _odesolverreport_owner &rhs);
+    virtual ~_odesolverreport_owner();
+    alglib_impl::odesolverreport* c_ptr();
+    const alglib_impl::odesolverreport* c_ptr() const;
+protected:
+    alglib_impl::odesolverreport *p_struct;
+    bool is_attached;
+};
+class odesolverreport : public _odesolverreport_owner
+{
+public:
+    odesolverreport();
+    odesolverreport(alglib_impl::odesolverreport *attach_to);
+    odesolverreport(const odesolverreport &rhs);
+    odesolverreport& operator=(const odesolverreport &rhs);
+    virtual ~odesolverreport();
+    ae_int_t &nfev;
+    ae_int_t &terminationtype;
+
+};
+#endif
+
+#if defined(AE_COMPILE_ODESOLVER) || !defined(AE_PARTIAL_BUILD)
+/*************************************************************************
+Cash-Karp adaptive ODE solver.
+
+This subroutine solves ODE  Y'=f(Y,x)  with  initial  conditions  Y(xs)=Ys
+(here Y may be single variable or vector of N variables).
+
+INPUT PARAMETERS:
+    Y       -   initial conditions, array[0..N-1].
+                contains values of Y[] at X[0]
+    N       -   system size
+    X       -   points at which Y should be tabulated, array[0..M-1]
+                integrations starts at X[0], ends at X[M-1],  intermediate
+                values at X[i] are returned too.
+                SHOULD BE ORDERED BY ASCENDING OR BY DESCENDING!
+    M       -   number of intermediate points + first point + last point:
+                * M>2 means that you need both Y(X[M-1]) and M-2 values at
+                  intermediate points
+                * M=2 means that you want just to integrate from  X[0]  to
+                  X[1] and don't interested in intermediate values.
+                * M=1 means that you don't want to integrate :)
+                  it is degenerate case, but it will be handled correctly.
+                * M<1 means error
+    Eps     -   tolerance (absolute/relative error on each  step  will  be
+                less than Eps). When passing:
+                * Eps>0, it means desired ABSOLUTE error
+                * Eps<0, it means desired RELATIVE error.  Relative errors
+                  are calculated with respect to maximum values of  Y seen
+                  so far. Be careful to use this criterion  when  starting
+                  from Y[] that are close to zero.
+    H       -   initial  step  lenth,  it  will  be adjusted automatically
+                after the first  step.  If  H=0,  step  will  be  selected
+                automatically  (usualy  it  will  be  equal  to  0.001  of
+                min(x[i]-x[j])).
+
+OUTPUT PARAMETERS
+    State   -   structure which stores algorithm state between  subsequent
+                calls of OdeSolverIteration. Used for reverse communication.
+                This structure should be passed  to the OdeSolverIteration
+                subroutine.
+
+SEE ALSO
+    AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults.
+
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+*************************************************************************/
+void odesolverrkck(const real_1d_array &y, const ae_int_t n, const real_1d_array &x, const ae_int_t m, const double eps, const double h, odesolverstate &state, const xparams _xparams = alglib::xdefault);
+void odesolverrkck(const real_1d_array &y, const real_1d_array &x, const double eps, const double h, odesolverstate &state, const xparams _xparams = alglib::xdefault);
+
+
+/*************************************************************************
+This function provides reverse communication interface
+Reverse communication interface is not documented or recommended to use.
+See below for functions which provide better documented API
+*************************************************************************/
+bool odesolveriteration(odesolverstate &state, const xparams _xparams = alglib::xdefault);
+
+
+/*************************************************************************
+This function is used to start iterations of the ODE solver
+
+It accepts following parameters:
+    diff    -   callback which calculates dy/dx for given y and x
+    ptr     -   optional pointer which is passed to diff; can be NULL
+
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+
+*************************************************************************/
+void odesolversolve(odesolverstate &state,
+    void (*diff)(const real_1d_array &y, double x, real_1d_array &dy, void *ptr),
+    void *ptr = NULL, const xparams _xparams = alglib::xdefault);
+
+
+/*************************************************************************
+ODE solver results
+
+Called after OdeSolverIteration returned False.
+
+INPUT PARAMETERS:
+    State   -   algorithm state (used by OdeSolverIteration).
+
+OUTPUT PARAMETERS:
+    M       -   number of tabulated values, M>=1
+    XTbl    -   array[0..M-1], values of X
+    YTbl    -   array[0..M-1,0..N-1], values of Y in X[i]
+    Rep     -   solver report:
+                * Rep.TerminationType completetion code:
+                    * -2    X is not ordered  by  ascending/descending  or
+                            there are non-distinct X[],  i.e.  X[i]=X[i+1]
+                    * -1    incorrect parameters were specified
+                    *  1    task has been solved
+                * Rep.NFEV contains number of function calculations
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+*************************************************************************/
+void odesolverresults(const odesolverstate &state, ae_int_t &m, real_1d_array &xtbl, real_2d_array &ytbl, odesolverreport &rep, const xparams _xparams = alglib::xdefault);
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (FUNCTIONS)
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib_impl
+{
+#if defined(AE_COMPILE_ODESOLVER) || !defined(AE_PARTIAL_BUILD)
+void odesolverrkck(/* Real    */ const ae_vector* y,
+     ae_int_t n,
+     /* Real    */ const ae_vector* x,
+     ae_int_t m,
+     double eps,
+     double h,
+     odesolverstate* state,
+     ae_state *_state);
+ae_bool odesolveriteration(odesolverstate* state, ae_state *_state);
+void odesolverresults(const odesolverstate* state,
+     ae_int_t* m,
+     /* Real    */ ae_vector* xtbl,
+     /* Real    */ ae_matrix* ytbl,
+     odesolverreport* rep,
+     ae_state *_state);
+void _odesolverstate_init(void* _p, ae_state *_state, ae_bool make_automatic);
+void _odesolverstate_init_copy(void* _dst, const void* _src, ae_state *_state, ae_bool make_automatic);
+void _odesolverstate_clear(void* _p);
+void _odesolverstate_destroy(void* _p);
+void _odesolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
+void _odesolverreport_init_copy(void* _dst, const void* _src, ae_state *_state, ae_bool make_automatic);
+void _odesolverreport_clear(void* _p);
+void _odesolverreport_destroy(void* _p);
+#endif
+
+}
+#endif
+

data/ext/alglib/extconf.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'mkmf-rice'
+
+create_makefile('alglib/alglib')