Metadata-Version: 2.1
Name: PyODESolver
Version: 0.1.2.dev0
Summary: A python package to solve first order ODEs
Home-page: https://github.com/Hoeppke/PyODESolver
Author: C. Hoeppke, A. Puiu
Author-email: christoph.hoeppke@maths.ox.ac.uk
License: MIT license
Description: # PyODESolver
        Python package for solving ODEs
        
        ## Installation
        
        To install PyODESolver execute:
        
            python3 -m pip install PyODESolver
        
        This will make the package pyodesolver available for import.
        To this this launch python3
        
            python3
        
        and import the new package pyodesolver
        
            import pyodesolver
        
        ## Quickstart guide:
        To get started with using PyODESolver include a solver method.
        In this example we will use the explicit euler method to solve
        the differential equation y'(t) = -2 * y(t), y(0) = pi. This
        differential equation has the exact solution
        
            y(t) = pi * exp(-2 * t).
        
        The right hand side in the expression
        
            y'(t) = -2*y(t),
            y(0) = pi
        
        is called a RHSFunction. This example has been implemented in
        ExampleFunc01 in the file rhs_function.py.
        To use the explicit euler solver for this ODE we first import
        the required files
        
            from method_explicit_euler import ExplicitEuler
            from rhs_function import ExampleFunc01
            import numpy as np
        
        we can than construct a method object in our main function
        and call generate on it to get the solver object.
        
        
            if __name__ == "__main__":
                N = 10**3
                t = np.linspace(0, 1, num=N)
                y0 = np.pi
                ee_solver = ExplicitEuler(N, y0, [0, 1], ExampleFunc01())
                solution = ee_solver.generate()
        
        The generator object is useful in this instance as it very
        lean in term of required memory and puts full control to the
        user at it allows to generate new time steps as required. For example
        one thread can be used for updating a plot and a different thread can
        call next(solution) to match the framerate of the plot.
        
        To extract the whole solution we can use:
        
            numericSol = []
            for (time, val) in solution:
                numericSol.append(val)
        
        To plot the solution in this example we can use
        
            import matplotlib.pyplot as plt
            plt.plot(t, np.array(numericSol))
            plt.show()
        
        
        ## Solving arbitrary ODEs
        
        To solve a customised ode the only two components required are
        the new RHSFunction and the Jacobian of this function. In cases
        where the Jacobian is unknown explicit methods will still function.
        
        To implement a new RHSFunction the user can inherit from RHSFunction
        and define a new subclass
        
            class NewFunction(RHSFunction):
            ...
        
        RHSFunction has exposes three methods that raise NotImplementedErrors.
        The user can then implement these methods by providing
        
            def eval(self, y_vec, time):
                ...
        
        and
        
            def jacobian(self, y_vec, time):
                ...
        
        to provide everything required for explicit and implicit methods.
        The solution can be obtained as described in the Quick-start-guide.
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
