Added the header for documentation to all .py files

This includes a basic description of the file and the License remark in
all the files created by me.

Imprived the documentation of ddFunction.py file.

Slightly improved the demo adding the creation of a more elaborate
element (for ISSAC'19 conference)

Several changes (fixing typos and starting documentation)

Makefile:
- Added dependency on doc to install the package before.

setup:
- Fixed the long_description property.

Documentation:
- Added documentation for some functions in ddExamples
- Started initial formal documentation for ddFunctions.py

Changed README to a Markdown document.

It explain now the installation process of the package.

Added new zip version for VERSION 0.7

Updated to version 0.7 (distribution almost available)

Merge branch 'setup_dist'.

Now the package can be install and updated. It is ready as a Python
package.

Now the package can create documentation from the docstrings
TODO: complete the docstrings for all the code.

Updated too the .gitignore to recognize all the compiled files

Added all the documentation files

Updated the Makefile: fixed small error in the name of the package

Small change in ddFunction.py

Deleted two (now) useless files

Added the Dockerfile for use of Binder

Fixed more errors while computing the _latex_ representation: errors
with names and recognizing zero coefficients.

Also added a Jupyter notebook as a demo for the package.

Fixed the _latex_ method for DDFunctions. Now the non-zero elements to
display in the differential equations are chosen properly.

Moreover, we fixed two syntax errors while formating the LaTeX lines.

Fixed a couple of errors in ddFunction.py and oreOperator.py due to the
last merge.

Added the .directory file for .gitignore

Merge branch 'master' of gitserver:pub/ajpastor/diff_defined_functions

Added rule in .gitignore for .directory files (configuration of Dolphin)

Added the latex method to ddFunctions

Fixed a bug on the _to_real_element method in conversion.py

Modified setup.py according the sage_sample project.

Added a GNUv3 LICENSE file

Changed the file package-version.txt to the more standard file VERSION

Updated the .gitignore file with lots of extra excluded files.

Updated the Makefile including now the commands for distribution and
installation of the package.

Revert "Adding extra files for distributing the package."

This reverts commit 10e2f2e55f32cbca18d6f56d2a110f61a861d89f.

Revert "Update repository"

This reverts commit 16f872e5e2f8251d08871ad31739e2d90fc89ec0.

Adding extra files for distributing the package.

Update repository

Update repository

Updating to last version

Fixed bug on conversion.py: error while computing the real value of
LazyElements due to the substitution method does not delete all variables
from the polynomial if they are not explicitly given.

Middle point implementing the complete DAlgebraic

Fixed some errors in lazyDDRing.py

Finished a first version of lazyDDRing

Now it can compute derivatives, create the lazy ring for DD-finite functions
and include elements that are also D-finite.

Fixed some errors in lazy/conversion.py and lazy/lazyRing.py

Fixed some errors in the files ddExamples and ddFunction

Added the Example for Riccati differential equations

Added a new zip file with the latest version of the code. This file will be linked
from any source for download.

Fixed the bug with the HypergeometricFunction method
Added a file to create custom Errors

Fixed an error while evaluating lazy elements

Error detected in the Hypergeometric function.

Added function for computing the inverse of a polynomial.

Updated the repository

Updated repository

Advanced a bit more in lazyDDRing

Added a file to manipulate sequence as functions over the integers.

Started the addition for a Lazy Conversion System for DDRings
using all the ideas for simplification got in the diffalg_reduction
method.

Updated version for debugging (more and better messages)

First implementation for diffalg_reduction finished.

Need to be further tested

Advanced the new implementation of diff_to_diffalg
- The computation of the vector v is still needed.

Started new implementation of diff_to_diffalg using the algorithm
described in the last paper.

Not yet finished

Added the hyperbolic inverses.

New features added to the DDRing structure:
- The method extend_base_field allows to extend the field of constants from a DDRing. Useful to add algebraic elements.

New examples functions:
- Tanh
- Arcsinh
- Arccosh
- Arctanh

Added option to stop the simplyify_homogeneous with linear equations.

Added new guessing functionality

Added three new methods to toDiffAlgebraic.py
- A method that, if y(x) = exp(int(u(x))), computes the differential polynomials
U_n(u) such that y^(n)(x) = y(x)U_n(u). (Exponential_polynomials)
- A method that, given an homogeneous differentially algebraic equation suppose
that the solution is of the form y(x) = exp(int(u(x))) and computes a
differentially algebraic equation for u(x) which will have less order than y(x).
(simplify_homogeneous)
- A method that, given an homogeneous differentially algebraic equation use the
method simplify_homogeneous and in case that a linear equation is achieved, then
a Dn-finite function is returned as an iteration of exponential functions
(guess_homogeenous_DNfinite).

Fixed a bug in the computation of algebraic equation for functional inverses.

Work done concerning the functional inverse of Dn-finite functions.

New feature:
- Method func_inverse_DA: it computes the differentially algebraic equation for the functional inverse of a Dn-finite function.
- Method FaaDiBruno_polynomials: method that returns the numerator and denominator of f^(k)(g(x)) as differential polynomials on g(x) when f(g(x)) = x.

Fixed some bugs:
- The name in the function Tan(x) is now properly initialized
- While printing names, the minos in front of the coefficients is now well treated
- Added equality check for computing the gcd of DDFunctions
- Added equality check for division computation

Added more examples:
- Arcsin, Arccos, Arctan
- The function Arccos create a parameter called 'pi'

Finiched the first version of the guess function for DC-finite functions

Merge branch 'master' of gitserver:pub/ajpastor/diff_defined_functions

Added optional aprameter in diff_to_diffalg and toDifferentiallyAlgebraic_Below
to allow the user decide when to print the final matrix or not.

Fixed an error in method inverse_DA that used by default the variables
returned by method diff_to_diffalg in the reversed order.

Added a small guess function for transform DA-equation to DD-finite

Added function to compute the equation for the multiplicative
inverse of DA-algebraic functions.

Fixed error with a casting using the InifitePolynomialRing when having
some parameters.

Improved the simplifier of functions.

Now from D(K[x]) we can simplify to K[x].

Fixed a couple of errors on the examples

Changed the basic examples to compute the differential equation directly instead that a composition

Fixed a small bug that threw errors in the LazyRing with DD-finite functions and over.

Added a method (not completed) to_simpler that reduces the basic ring. The part for order 1 D-finite functions works properly.

Finished the implementation of __pow__ for DDFunctions.

Now it allows to compute the power of DDFunctions to any other
DDFunction (if some conditions with the initial values hold).
See documentation of __pow__ in DDFunction class for more information.

Fixed small error in Log

Fixed error in toDiffAlgebraic

Added the power with power series.

Detected error in file toDiffAlgebraic.py (see todo)

Check webpage http://functions.wolfram.com/EllipticFunctions/DedekindEta/13/01/

Added generic example for contiguous equation for HypergeometricFunction

Fixed test file ddFunction.py to not use all global variables.

Changed version to 0.6 (since addition of file toDiffAlgebraic.py)
Renamed previous releases to fit with the version

Fixed two errors:
    - Function sequence from ring_w_sequence.py now allows Symbolic Expressions as input
    - Functions __rsub__ and __rdiv__ now work properly (previously returned wrong results (inversed))

Modified the _element_constructor_ method of DDFunction to allow elements in
the FractionField of the base domain.

Added combinatorial examples: Fibonacci (with option to two parameters) and Catalan numbers

Fixed a typo in ddExamples.py

Finished the documentation of file ddExamples.py

Updated some examples to allow parameters as input, not only in the arguments
of the functions, but also in the initial values.

Add more documentation.

Improved the implementation of the LegendreD function: now more type of
Legendre associated functions are allowed.

Started documentation of Chebyshev polynomials.

Fixed small errors in ddFunction.py

Added all the examples from DLMF website.

Started adding the documentation for all the examples.

Updated the algorithm diff_to_diffalg to allow parameters in the
DDRings.

Added example with Hill equation

Modified the Hypergeometric example to allow parameters

Updated the Struve example
Started the example of Legendre elliptic integrals

Added more examples of D-finite functions.

Added Airy functions and ParabolicCylindric Functions

First test with D3Finite functions.

Added algorithm for DiffAlgOver(k) --> DiffAlgOver(k-1)

Added the file with the D^k --> DA functions.

Modified the ddFunction file in order to compile properly.

Added a .gitignore so no .pyc file is tracked.

Small changes in fles ddFunction.py and matrix.py

The initial values for the polynomial computation is finished.

It is based in a recursive structure using the generalized Leibniz rule
for decomposing the products in the monomials, and Bruno di Faa's formula
for the power of variables.

Modified the method to decide parents for the example functions

Started to add the method to compute polynomials directly (Not finished)

Deleted a print line in the method random_element in the class DDRing

Fixed error in method random_element in class DDRing

Added the method random_element to the class ddRing

Revert "Added the method random_element to the class DDRing"

This reverts commit ac3682813da3e9400fd19d5e13d2d6ca2e7d557b.

Added the method random_element to the class DDRing

Adapted files of package misc to Python.

Other deprecated files (i.e., never used) were deleted.

Files adapted: bareiss.py, matrix.py, ring_w_sequence.py, verbose.py
Files deleted: euclidean.py, hermite.py, nullspace_wrapper.py,
storj_villard.py, timing.py

Final version after visit to Paris

Performance improvements

1 - The method for computing the root of the indicial polynomial now is cached.
This means that operators with the same indicial polynomial take less time to
compute their roots.
2 - Computing th roots of the indicial polynomial when there are parameters is done
using a modular approximation: we evaluate the parameters and when the polynomial
has the same degree we compute the roots of a univariate polynomial. That is a superset
of the roots we want, so we check and we keep those that were roots for the indicial polynomial.

Minor changes:
   matrix.py now use the method is_Matrix instead of sage.matrix.Matrix (deprecated in
SAGE: https://trac.sagemath.org/ticket/24096

Added the README file to the repository.

No changes within the code.

Added an heuristic zero testing for Lazy Elements.

Now, before going to the real value, it checks that the initial value of
the lazy element at zero is zero. Otherwise, the method is_zero
of the class _LazyElement returns directly False

New version of the packages.

Now the class DDRing accepts algebraic extensions of QQ as
basic field. Also, this field is dinamicall computed assuming
that, if the base ring is a Polynomial Ring, the base field
is the same as the coefficients of the polynomials.

some version

Setting up the public repository for the SAGE implementation Differentially Definable Functions.