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.