improved documentation

Author: Bumblebee00

README.md

@@ -2,70 +2,52 @@
 
 [![Build Status](https://github.com/JuliaSymbolics/SymbolicIntegration.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/JuliaSymbolics/SymbolicIntegration.jl/actions/workflows/CI.yml?query=branch%3Amain)
 [![Spell Check](https://github.com/JuliaSymbolics/SymbolicIntegration.jl/actions/workflows/spellcheck.yml/badge.svg?branch=main)](https://github.com/JuliaSymbolics/SymbolicIntegration.jl/actions/workflows/spellcheck.yml)
+[![Rules](https://img.shields.io/badge/dynamic/json?url=https://raw.githubusercontent.com/JuliaSymbolics/SymbolicIntegration.jl/main/.github/badges/rules-count.json&query=$.message&label=Total%20rules&color=blue)](https://github.com/JuliaSymbolics/SymbolicIntegration.jl)
 
 
-SymbolicIntegration.jl provides a flexible, extensible framework for symbolic integration with multiple algorithm choices.
+SymbolicIntegration.jl solves indefinite integrals using one of the implemented algorithms: Risch method and Rule based method
 
 
 # Usage
-
-### Installation
 ```julia
-julia> using Pkg; Pkg.add("SymbolicIntegration")
-```
-
-### Basic Integration
+julia> using Pkg; Pkg.add("SymbolicIntegration") # installation
 
-```julia
 julia> using SymbolicIntegration, Symbolics
 
 julia> @variables x
 1-element Vector{Num}:
  x
 
-julia> integrate(x^2,x)
-(1//3)*(x^3)
-
-julia> integrate(x+x^2)
-(1//2)*(x^2) + (1//3)*(x^3)
-
+julia> integrate(exp(2x) + 2x^2 + sin(x))
+(1//2)*exp(2x) + (2//3)*(x^3) - cos(x)
 ```
 The first argument is the expression to integrate, second argument is the variable of integration. If the variable is not specified, it will be guessed from the expression. The +c is omitted :)
 
 ### Method Selection
 
 You can explicitly choose a integration method like this:
 ```julia
-# Explicit method choice
 risch = RischMethod(use_algebraic_closure=true, catch_errors=false)
 integrate(f, x, risch)
 ```
-or
+or like this:
 ```julia
 rbm = RuleBasedMethod(verbose=true, use_gamma=false)
 integrate(f, x, rbm)
 ```
 
 If no method is specified, first RischMethod will be tried, then RuleBasedMethod:
 ```julia
-julia> integrate(2x)
-x^2
-
 julia> integrate(sqrt(x))
 ┌ Warning: NotImplementedError: integrand contains unsupported expression sqrt(x)
 └ @ SymbolicIntegration ~/.julia/dev/SymbolicIntegration.jl_official/src/methods/risch/frontend.jl:826
 
  > RischMethod failed returning ∫(sqrt(x), x) 
  > Trying with RuleBasedMethod...
 
-┌-------Applied rule 1_1_1_1_2 on ∫(sqrt(x), x)
-| ∫(x ^ m, x) => if 
-|       !(contains_var(m, x)) &&
-|       !(eq(m, -1))
-| x ^ (m + 1) / (m + 1)
-└-------with result: (2//3)*(x^(3//2))
 (2//3)*(x^(3//2))
-
+```
+```julia
 julia> integrate(abs(x))
 ┌ Warning: NotImplementedError: integrand contains unsupported expression abs(x)
 └ @ SymbolicIntegration ~/.julia/dev/SymbolicIntegration.jl_official/src/methods/risch/frontend.jl:826
@@ -84,28 +66,26 @@ No rule found for ∫(abs(x), x)
 # Integration Methods
 Currently two algorithms are implemented: **Risch algorithm** and **Rule based integration**.
 
-## Risch Method
+feature | Risch | Rule based
+--------|-------|-----------
+rational functions | ✅ | ✅
+non integers powers | ❌ | ✅
+exponential functions | ✅ | ✅
+logarithms  | ✅ | ✅
+trigonometric functions | ? | sometimes
+hyperbolic functions  | ✅ | sometimes
+Nonelementary integrals | ❌ | most of them
+Special functions | ❌ | ❌
+more than one symbolic<br> variable in the expression  | ❌ | ✅
+
+More info about them in the [methods documentation](methods/overview.md)
+
+### Risch Method
 Complete symbolic integration using the Risch algorithm from Manuel Bronstein's "Symbolic Integration I: Transcendental Functions".
 
-**Capabilities:**
-- ✅ **Rational functions**: Complete integration with Rothstein-Trager method
-- ✅ **Transcendental functions**: Exponential, logarithmic using differential field towers
-- ✅ **Complex roots**: Exact arctangent terms for complex polynomial roots
-- ✅ **Integration by parts**: Logarithmic function integration
-- ✅ **Trigonometric functions**: Via transformation to exponential form
-- ❌ **More than one symbolic variable**: Integration w.r.t. one variable, with other symbolic variables present in the expression
-
-## RuleBasedMethod
-
-[![Rules](https://img.shields.io/badge/dynamic/json?url=https://raw.githubusercontent.com/JuliaSymbolics/SymbolicIntegration.jl/main/.github/badges/rules-count.json&query=$.message&label=Total%20rules&color=blue)](https://github.com/JuliaSymbolics/SymbolicIntegration.jl)
-
-This method uses a rule based approach to integrate a vast class of functions, and it's built using the rules from the Mathematica package [RUBI](https://rulebasedintegration.org/).
-
-**Capabilities:**
-- ✅ Fast convergence for a large base of recognized cases
-- ✅ Algebraic functions like `sqrt` and non-integer powers are supported
-- ✅ **More than one symbolic variable**: Integration w.r.t. one variable, with other symbolic variables present in the expression
+### RuleBasedMethod
 
+This method uses a large number of integration rules that specify how to integrate various mathematical expressions. There are now more than 3400 rules impelmented.
 
 # Documentation
 
@@ -119,7 +99,7 @@ If you use SymbolicIntegration.jl in your research, please cite:
 
 ```bibtex
 @software{SymbolicIntegration.jl,
-  author = {Harald Hofstätter and Mattia Micheletta Merlin},
+  author = {Harald Hofstätter and Mattia Micheletta Merlin and Chris Rackauckas},
   title = {SymbolicIntegration.jl: Symbolic Integration for Julia},
   url = {https://github.com/JuliaSymbolics/SymbolicIntegration.jl},
   year = {2023-2025}

docs/src/index.md

@@ -19,7 +19,7 @@ using SymbolicIntegration, Symbolics
 
 @variables x a
 
-# Basic polynomial integration (uses default RischMethod)
+# Basic polynomial integration
 integrate(x^2, x)  # Returns (1//3)*(x^3)
 
 # Rational function integration
@@ -39,62 +39,47 @@ integrate(f, x, RischMethod(use_algebraic_closure=true))  # With options
 
 ## Integration Methods
 
-SymbolicIntegration.jl provides multiple integration algorithms through a flexible method dispatch system:
+SymbolicIntegration.jl provides two integration algorithms: Rule based and Risch method. Here is a quick table to see what they can integrate:
 
-### RischMethod
-The complete Risch algorithm for elementary function integration:
-- **Exact results**: Guaranteed correct symbolic integration
-- **Complex roots**: Produces exact arctangent terms  
-- **Complete coverage**: Rational and transcendental functions
-- **Configurable**: Options for performance vs completeness
-
-```julia
-# Default method
-integrate(f, x)  
-
-# Explicit method with options
-integrate(f, x, RischMethod(use_algebraic_closure=true))
-```
+feature | Risch | Rule based
+--------|-------|-----------
+rational functions | ✅ | ✅
+non integers powers | ❌ | ✅
+exponential functions | ✅ | ✅
+logarithms  | ✅ | ✅
+trigonometric functions | ? | sometimes
+hyperbolic functions  | ✅ | sometimes
+Nonelementary integrals | ❌ | most of them
+Special functions | ❌ | ❌
+more than one symbolic<br> variable in the expression  | ❌ | ✅
 
-Is implemented in a generic way using [AbstractAlgebra.jl](https://nemocas.github.io/AbstractAlgebra.jl/dev/). Some algorithms require [Nemo.jl](https://nemocas.github.io/Nemo.jl/dev/) for calculations with algebraic numbers.
+[→ See complete methods documentation](methods/overview.md)
 
-Is based on the algorithms from the book:
+### RischMethod
+This method is based on the algorithms from the book:
 
 > Manuel Bronstein, [Symbolic Integration I: Transcentental Functions](https://link.springer.com/book/10.1007/b138171), 2nd ed, Springer 2005,
 
-for which a pretty complete set of reference implementations is provided.
+for which a pretty complete set of reference implementations is provided. As in the book, integrands involving algebraic functions like `sqrt` and non-integer powers are not treated.
 
-Currently, RischMethod can integrate:
-- Rational functions
-- Integrands involving transcendental elementary functions like `exp`, `log`, `sin`, etc.
-
-As in the book, integrands involving algebraic functions like `sqrt` and non-integer powers are not treated.
+```julia
+integrate(x^2 + 1, x, RischMethod(use_algebraic_closure=false, catch_errors=true))
+```
+- `use_algebraic_closure` does what?
+- `catch_errors` does what?
 
-!!! note
-    SymbolicIntegration.jl is still in an early stage of development and should not be expected to run stably in all situations.
-    It comes with absolutely no warranty whatsoever.
+[→ See detailed Risch documentation](risch.md)
 
 ### RuleBased
-TODO add
-
-[→ See complete methods documentation](methods/overview.md)
-
-## Algorithm Coverage
+This method uses a large number of integration rules that specify how to integrate various mathematical expressions.
 
-The **RischMethod** implements the complete suite of algorithms from Bronstein's book:
-
-- **Rational Function Integration** (Chapter 2)
-  - Hermite reduction
-  - Rothstein-Trager method for logarithmic parts
-  - Complexification and real form conversion
-
-- **Transcendental Function Integration** (Chapters 5-6)  
-  - Risch algorithm for elementary functions
-  - Differential field towers
-  - Primitive and hyperexponential cases
+```julia
+integrate(x^2 + 1, x, RuleBasedMethod(verbose=true, use_gamma=false))
+```
+- `verbose` specifies whether to print or not the integration rules applied (default true)
+- `use_gamma` specifies whether to use rules with the gamma function in the result, or not (default false)
 
-- **Algebraic Function Integration** (Future work)
-  - Currently not implemented
+[→ See detailed Rule based documentation](methods/rulebased.md)
 
 ## Contributing
 
@@ -106,7 +91,7 @@ If you use SymbolicIntegration.jl in your research, please cite:
 
 ```bibtex
 @software{SymbolicIntegration.jl,
-  author = {Harald Hofstätter and contributors},
+  author = {Harald Hofstätter and Mattia Micheletta Merlin and Chris Rackauckas},,
   title = {SymbolicIntegration.jl: Symbolic Integration for Julia},
   url = {https://github.com/JuliaSymbolics/SymbolicIntegration.jl},
   year = {2023-2025}

docs/src/manual/basic_usage.md

@@ -1,3 +1,17 @@
+- [Contributing to improving RuleBasedMethod](#contributing-to-improving-rulebasedmethod)
+  - [Common problems when translating rules](#common-problems-when-translating-rules)
+    - [function not translated](#function-not-translated)
+    - [Sum function translation](#sum-function-translation)
+    - [Module syntax translation](#module-syntax-translation)
+    - [\* not present or present as \[Star\]](#-not-present-or-present-as-star)
+  - [Description of the script `src/translator_of_rules.jl`](#description-of-the-script-srctranslator_of_rulesjl)
+    - [How to use it](#how-to-use-it)
+    - [How it works internally (useful to know if you have to debug it)](#how-it-works-internally-useful-to-know-if-you-have-to-debug-it)
+      - [With syntax](#with-syntax)
+      - [replace and smart\_replace applications](#replace-and-smart_replace-applications)
+      - [Pretty indentation](#pretty-indentation)
+      - [end](#end)
+  - [Adding Testsuites](#adding-testsuites)
 
 # Contributing to improving RuleBasedMethod
 
@@ -154,3 +168,6 @@ applied automatically that rewrites the rule like this:
 #### end
 finally the rule is placed in a tuple (index, rule), and all the
 tuples are put into a array, ready to be included by load_rules
+
+## Adding Testsuites
+There is a test suite of 27585 solved integrals taken from the RUBI package, in the folders `test/test_files/0 Independent test suites` (1796 tests) and `test/test_files/1 Algebraic functions` (25798 tests). But more test can be translated from the [RUBI testsuite](https://rulebasedintegration.org/testProblems.html). In [this](https://github.com/Bumblebee00/SymbolicIntegration.jl?tab=readme-ov-file#testing) repo there are the tests still in Mathematica syntax and a script to transalte them to julia.