Metadata-Version: 1.1
Name: differint
Version: 0.3
Summary: Collection of algorithms for numerically calculating fractional derivatives.
Home-page: http://github.com/differint/differint
Author: Matthew Adams
Author-email: Matthew.Adams@ucalgary.ca
License: MIT
Description: ## differint
        This package is used for numerically calculating fractional derivatives and integrals (differintegrals). Options for varying definitions of the differintegral are available, including the Grunwald-Letnikov (GL), the 'improved' Grunwald-Letnikov (GLI), the Riemann-Liouville (RL), and the Caputo (coming soon!). Through the API, you can compute differintegrals at a point or over an array of function values.
        
        ## Motivation
        There is little in the way of readily available, easy-to-use code for numerical fractional calculus. What is currently available are functions that are generally either smart parts of a much larger package, or only offer one numerical algorithm. The *differint* package offers a variety of algorithms for computing differintegrals and several auxiliary functions relating to generalized binomial coefficients.
        
        ## Installation
        This project requires Python 3+ and NumPy to run.
        
        Installation from the Python Packaging index (https://pypi.python.org/pypi) is simple using pip.
        
        ```python
        pip install differint
        ```
        
        ## Example Usage
        Taking a fractional derivative is easy with the *differint* package. Let's take the 1/2 derivative of the square root function on the interval [0,1], using the Riemann-Liouville definition of the fractional derivative.
        
        ```python
        import numpy as np
        import differint as df
        
        def f(x):
           return x**0.5
        
        DF = df.RL(0.5, f)
        print(DF)
        ```
        
        You can also specify the endpoints of the domain and the number of points used as follows.
        
        ```python
        DF = df.RL(0.5, f, 0, 1, 128)
        ```
        
        ## Tests
        All tests can be run with nose from the command line. Setup will automatically install nose if it is not present on your machine.
        
        ```python
        python setup.py tests
        ```
        
        Alternatively, you can run the test script directly.
        
        ```python
        cd <file_path>/differint/tests/
        python test.py
        ```
        
        ## API Reference
        In this section we cover the usage of the various functions within the *differint* package.
        
        Main Function | Usage
        ------------- | -----
        GLpoint | Computes the GL differintegral at a point
        GL | Computes the GL differintegral over an entire array of function values using the Fast Fourier Transform
        GLI | Computes the improved GL differintegral over an entire array of function values
        RLpoint | Computes the RL differintegral at a point
        RL | Computes the RL differintegral over an entire array of function values using matrix methods
        
        Auxiliary Function | Usage
        ------------------ | -----
        isInteger | Determine if a number is an integer
        checkValues | Used to check for valid algorithm input types
        GLIinterpolat | Define interpolating coefficients for the improved GL algorithm
        functionCheck | Determines if algorithm function input is callable or an array of numbers
        test_func | Testing function for docstring examples
        poch | Computes the Pochhammer symbol
        GLcoeffs | Determines the convolution filter composed of generalized binomial coefficients used in the GL algorithm
        RLcoeffs | Calculates the coefficients used in the RLpoint and RL algorithms
        RLmatrix | Determines the matrix used in the RL algorithm
        
        ## How to use?
        
        
        ## Contribute
        
        To contribute to this project, see the [contributing guidelines](https://github.com/snimpids/differint/blob/master/CONTRIBUTING.md).
        
        ## Credits
        Baleanu, D., Diethelm, K., Scalas, E., & Trujillo, J.J. (2012). Fractional Calculus: Models and Numerical Methods. World Scientific.
        
        Oldham, K.B. & Spanier, J. (1974). The Fractional Calculus: Theory and Applications of Differentiation and Integration to Arbitrary Order. Academic Press Inc. 
        
        ## License
        
        MIT Â© [Matthew Adams](2018)
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3.3
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
