Add rule based integration method

.github/badges/rules-count.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "Total rules",
+  "message": "3399",
+  "color": "blue"
+}

.github/dependabot.yml

@@ -0,0 +1,7 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/ci.yml

@@ -23,6 +23,7 @@ jobs:
         version:
           - '1.10'
           - '1'
+          - 'pre'
         os:
           - ubuntu-latest
           - macos-latest
@@ -37,7 +38,53 @@ jobs:
           arch: ${{ matrix.arch }}
       - uses: julia-actions/cache@v2
       - uses: julia-actions/julia-buildpkg@v1
-      - uses: julia-actions/julia-runtest@v1
+      - name: Run tests julia 1.11 ubuntu-latest and count rules
+        if: matrix.version == '1' && matrix.os == 'ubuntu-latest'
+        run: |
+          julia --project=. -e "
+            using SymbolicIntegration
+            using Pkg
+
+            rules_count = length(SymbolicIntegration.RULES)
+            println(\"Total rules: \$rules_count\")
+
+            # Create directory if it doesn't exist
+            mkpath(\".github/badges\")
+
+            # Write the JSON file manually
+            open(\".github/badges/rules-count.json\", \"w\") do f
+                println(f, \"{\")
+                println(f, \"  \\\"schemaVersion\\\": 1,\")
+                println(f, \"  \\\"label\\\": \\\"Total rules\\\",\")
+                println(f, \"  \\\"message\\\": \\\"\$rules_count\\\",\")
+                println(f, \"  \\\"color\\\": \\\"blue\\\"\")
+                println(f, \"}\")
+            end
+
+            println(\"Badge data written to .github/badges/rules-count.json\")
+
+            Pkg.test()
+          "
+        id: count_rules
+
+      - name: Commit badge data
+        if: matrix.version == '1' && matrix.os == 'ubuntu-latest' && github.ref == 'refs/heads/main'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add .github/badges/rules-count.json
+          if git diff --staged --quiet; then
+            echo "No changes to commit"
+          else
+            git commit -m "Update rules count badge [skip ci]"
+            git push
+          fi
+
+      - name: Run tests (other configurations)  
+        if: ${{ !(matrix.version == '1' && matrix.os == 'ubuntu-latest') }}
+        uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v5
         with:

.github/workflows/spellcheck.yml

@@ -0,0 +1,13 @@
+name: Spell Check
+
+on: [push, pull_request]
+
+jobs:
+  typos-check:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v4
+      - name: Check spelling
+        uses: crate-ci/typos@v1.16.23

LICENSE

@@ -1,6 +1,6 @@
 SymbolicIntegration.jl is licensed under the MIT License:
 
-Copyright (c) 2022 Harald Hofstätter
+Copyright (c) 2022 Harald Hofstätter, Mattia Micheletta Merlin, Chris Rackauckas, and other contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Project.toml

@@ -1,28 +1,40 @@
 name = "SymbolicIntegration"
 uuid = "315ce56f-eed0-411d-ab8a-2fbdf9327b51"
-authors = ["HaraldHofstaetter <hofi@harald-hofstaetter.at>", "Chris Rackauckas <accounts@chrisrackauckas.com>", "JuliaSymbolics contributors"]
-version = "2.0.0"
+keywords = ["symbolic", "integration", "mathematics", "computer-algebra"]
+license = "MIT"
+authors = ["HaraldHofstaetter <hofi@harald-hofstaetter.at>", "Mattia Micheletta Merlin <micheletta.mattia@gmail.com>", "Chris Rackauckas <accounts@chrisrackauckas.com>", "JuliaSymbolics contributors"]
 description = "Symbolic integration algorithms for Julia"
 repository = "https://github.com/JuliaSymbolics/SymbolicIntegration.jl"
-license = "MIT"
-keywords = ["symbolic", "integration", "mathematics", "computer-algebra"]
+version = "2.0.0"
 
 [deps]
 AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
+Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
+Elliptic = "b305315f-e792-5b7a-8f41-49f472929428"
+FresnelIntegrals = "88497964-e39a-11e9-0fb5-b1bf0ffe80fe"
+HypergeometricFunctions = "34004b35-14d8-5ef3-9330-4cdb6864b03a"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 Nemo = "2edaba10-b0f1-5616-af89-8c11ac63239a"
+PolyLog = "85e3b03c-9856-11eb-0374-4dc1f8670e7f"
 SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b"
 Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 
 [compat]
 AbstractAlgebra = "0.46"
+Combinatorics = "1.0.2"
+Elliptic = "1.0.1"
+FresnelIntegrals = "0.2.0"
+HypergeometricFunctions = "0.3.28"
 Nemo = "0.51"
+PolyLog = "2.6.0"
 SymbolicUtils = "3"
 Symbolics = "6"
 julia = "1.10"
 
 [extras]
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test"]
+test = ["Test", "Pkg", "Dates"]

README.md

@@ -1,119 +1,105 @@
 # SymbolicIntegration.jl
 
-*A unified interface for symbolic integration methods in Julia*
+[![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. The package uses method dispatch to allow users to select the most appropriate integration algorithm for their specific needs.
 
-## Key Features
+SymbolicIntegration.jl solves indefinite integrals using one of the implemented algorithms: Risch method and Rule based method
 
-- 🎯 **Multiple Integration Methods**: Extensible method dispatch system
-- ⚡ **Exact Symbolic Results**: Guaranteed correct symbolic integration  
-- 🔢 **Complex Root Handling**: Produces exact arctangent terms
-- ⚙️ **Configurable Algorithms**: Method-specific options and behavior
-- 🏗️ **Professional Interface**: SciML-style method selection
 
-## Integration Methods
-
-### RischMethod (Default)
-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
-
-**Function Classes:**
-- Polynomial functions: `∫x^n dx`, `∫(ax^2 + bx + c) dx`
-- Rational functions: `∫P(x)/Q(x) dx` → logarithmic and arctangent terms
-- Exponential functions: `∫exp(f(x)) dx`, `∫x*exp(x) dx`
-- Logarithmic functions: `∫log(x) dx`, `∫1/(x*log(x)) dx`
-- Trigonometric functions: `∫sin(x) dx`, `∫cos(x) dx`, `∫tan(x) dx`
-
-The framework is designed to support additional integration methods as they are developed.
-
-
-
-## Installation
+# Usage
 ```julia
-julia> using Pkg; Pkg.add("SymbolicIntegration")
-```
+julia> using Pkg; Pkg.add("SymbolicIntegration") # installation
 
-## Usage
+julia> using SymbolicIntegration, Symbolics
 
-### Basic Integration
+julia> @variables x
+1-element Vector{Num}:
+ x
 
-```julia
-using SymbolicIntegration, Symbolics
-@variables x
-
-# Default method (RischMethod) - most cases
-integrate(x^2, x)                    # (1//3)*(x^3)
-integrate(1/x, x)                    # log(x)
-integrate(exp(x), x)                 # exp(x)
-integrate(1/(x^2 + 1), x)           # atan(x)
+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
-integrate(f, x, RischMethod())
-
-# Method with configuration
 risch = RischMethod(use_algebraic_closure=true, catch_errors=false)
 integrate(f, x, risch)
 ```
+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(sqrt(x))
+┌ Warning: NotImplementedError: integrand contains unsupported expression sqrt(x)
+└ @ SymbolicIntegration ~/.julia/dev/SymbolicIntegration.jl_official/src/methods/risch/frontend.jl:826
 
-### Complex Examples
+ > RischMethod failed returning ∫(sqrt(x), x) 
+ > Trying with RuleBasedMethod...
 
+(2//3)*(x^(3//2))
+```
 ```julia
-# Rational function with complex roots
-f = (x^3 + x^2 + x + 2)/(x^4 + 3*x^2 + 2)
-integrate(f, x)  # (1//2)*log(2 + x^2) + atan(x)
+julia> integrate(abs(x))
+┌ Warning: NotImplementedError: integrand contains unsupported expression abs(x)
+└ @ SymbolicIntegration ~/.julia/dev/SymbolicIntegration.jl_official/src/methods/risch/frontend.jl:826
+
+ > RischMethod failed returning ∫(abs(x), x) 
+ > Trying with RuleBasedMethod...
 
-# Integration by parts
-integrate(log(x), x)  # -x + x*log(x)
+No rule found for ∫(abs(x), x)
+
+ > RuleBasedMethod failed returning ∫(abs(x), x) 
+ > Sorry we cannot integrate this expression :(
 
-# Nested transcendental functions
-integrate(1/(x*log(x)), x)  # log(log(x))
 ```
 
-## Method Framework
 
-SymbolicIntegration.jl uses a modern method dispatch system similar to other SciML packages:
+# Integration Methods
+Currently two algorithms are implemented: **Risch algorithm** and **Rule based integration**.
 
-### Current Methods
-- **RischMethod**: Complete symbolic integration (default)
+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  | ❌ | ✅
 
-### Method Configuration
-```julia
-# Research configuration (strict, complete)
-RischMethod(use_algebraic_closure=true, catch_errors=false)
+More info about them in the [methods documentation](methods/overview.md)
 
-# Production configuration (robust, graceful)  
-RischMethod(use_algebraic_closure=true, catch_errors=true)
+### Risch Method
+Complete symbolic integration using the Risch algorithm from Manuel Bronstein's "Symbolic Integration I: Transcendental Functions".
 
-# Performance configuration (faster, simpler)
-RischMethod(use_algebraic_closure=false, catch_errors=true)
-```
+### RuleBasedMethod
 
-### Extensibility
-The framework is designed for easy extension with additional integration methods. The abstract type `AbstractIntegrationMethod` provides the foundation for implementing new algorithms.
+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
+# Documentation
 
 Complete documentation with method selection guidance, algorithm details, and examples is available at:
 **[https://symbolicintegration.juliasymbolics.org](https://symbolicintegration.juliasymbolics.org)**
 
-## Citation
+
+# Citation
 
 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}