prepare deprecation of simple and alternative

.github/workflows/downstream.yml

@@ -0,0 +1,49 @@
+name: IntegrationTest
+on:
+  push:
+    branches: [master]
+    tags: [v*]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.package.repo }}/${{ matrix.package.group }}/${{ matrix.julia-version }}
+    runs-on: ${{ matrix.os }}
+    env:
+      GROUP: ${{ matrix.package.group }}
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: [1]
+        os: [ubuntu-latest]
+        package:
+          - {user: lrnv, repo: Copulas.jl, group: All}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: x64
+      - uses: julia-actions/julia-buildpkg@latest
+      - name: Clone Downstream
+        uses: actions/checkout@v6
+        with:
+          repository: ${{ matrix.package.user }}/${{ matrix.package.repo }}
+          path: downstream
+      - name: Load this and run the downstream tests
+        shell: julia --color=yes --project=downstream {0}
+        run: |
+          using Pkg
+          try
+            # force it to use this PR's version of the package
+            Pkg.develop(PackageSpec(path="."))  # resolver may fail with main deps
+            Pkg.update()
+            Pkg.test()  # resolver may fail with test time deps
+          catch err
+            err isa Pkg.Resolve.ResolverError || rethrow()
+            # If we can't resolve that means this is incompatible by SemVer and this is fine
+            # It means we marked this as a breaking change, so we don't need to worry about
+            # Mistakenly introducing a breaking change, as we have intentionally made one
+            @info "Not compatible with this release. No problem." exception=err
+            exit(0)  # Exit immediately, as a success
+          end

Project.toml

@@ -1,6 +1,6 @@
 name = "Roots"
 uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665"
-version = "3.0.0"
+version = "3.0.6"
 
 [deps]
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
@@ -32,7 +32,7 @@ ChainRulesCore = "1"
 ChainRulesTestUtils = "1"
 CommonSolve = "0.1, 0.2"
 ForwardDiff = "0.10, 1"
-IntervalRootFinding = "0.5, 0.6"
+IntervalRootFinding = "0.5, 0.6, 0.7"
 JET = "0.9, 0.10, 0.11"
 JSON = "0.21, 1"
 Measurements = "2.11"

docs/src/index.md

@@ -6,7 +6,7 @@ Documentation for [Roots.jl](https://github.com/JuliaMath/Roots.jl)
 ## About
 
 `Roots` is  a `Julia` package  for finding zeros of continuous
-scalar functions of a single real variable using floating point numbers. That  is solving ``f(x)=0`` for ``x`` adjusting for floating-point idiosyncrasies.
+scalar functions of a single real variable using floating point numbers. That is, solving ``f(x)=0`` for ``x`` adjusting for floating-point idiosyncrasies.
 
 The `find_zero` function provides the
 primary interface. It supports various algorithms through the
@@ -21,9 +21,9 @@ specification of a method. These include:
   computations allows. Other methods include `A42`,
   `AlefeldPotraShi`, `Roots.Brent`, `Roots.Chandrapatlu`,
   `Roots.ITP`, `Roots.Ridders`, `Roots.ModAB`, and ``12``-flavors of
-  `FalsePosition`. The default bracketing method for
+  `FalsePosition` and a few in `RegularFalsi`. The default bracketing method for
   the basic floating-point types is `Bisection` , as it is more robust to some inputs,
-  but `A42` and `AlefeldPotraShi` typically converge in a few
+  but `Roots.ModAB`, `A42` and `AlefeldPotraShi` typically converge in a few
   iterations and are more performant.
 
 
@@ -32,7 +32,7 @@ specification of a method. These include:
   (the Steffensen method), `Order5`, `Order8`, and `Order16`. The
   number indicates, roughly, the order of convergence. The `Order0`
   method is the default, and the most robust, as it finishes off with
-  a bracketing method when a bracket is encountered, The higher order
+  a bracketing method when a bracket is encountered, The higher-order
   methods promise higher order (faster) convergence, though don't
   always yield results with fewer function calls than `Order1` or
   `Order2`. `Roots.Sidi` is a family of methods.

docs/src/reference.md

@@ -142,6 +142,7 @@ Roots.Chandrapatla
 Roots.Ridders
 Roots.ITP
 Roots.ModAB
+Roots.RegulaFalsi
 FalsePosition
 Roots.LithBoonkkampIJzermanBracket
 Roots.BracketedHalley
@@ -227,9 +228,12 @@ good example.
 | Bracketing      | A42                          | ``(2 + 7^{1/2})``      | ``3,4`` |``(2 + 7^{1/2})^{1/3} = 1.6686\dots``  |
 | Bracketing      | AlefeldPotraShi              |                        | ``3,4`` | ``1.618\dots``                        |
 | Bracketing      | Brent                        | ``\leq 1.89\dots``     | ``1``   | ``\leq 1.89\dots``                    |
-| Bracketing      | ITP                          | ``\leq \varphi``         | ``1``   | ``\leq \varphi``                      |
+| Bracketing      | ITP                          | ``\leq \varphi``       | ``1``   | ``\leq \varphi``                      |
 | Bracketing      | Ridders                      | ``1.83\dots``          | ``2``   | ``1.225\dots``                          |
-| Bracketing      | FalsePosition                | ``1.442\dots``         | ``1``   | ``1.442\dots``                        |
+| Bracketing      | RegularFalsi{:classic}       | ``1``                  | ``1``   | ``1``                                 |
+| Bracketing      | RegularFalsi{:Illinois}      | ``1.442\dots``         | ``1``   | ``1.442\dots``                        |
+| Bracketing      | RegulaFalsi{:AndersonBjork}  | ``1.681\dots``         | ``1``   | ``1.681\dots``                        |
+| Bracketing      | RegulaFalsi{:Ford4}          | ``1.681\dots``         | ``1``   | ``1.681\dots``                        |
 | Bracketing      | ModAB                        | ``≈1.7\dots``          | ``1``   | ``1.7\dots``                          |
 | Bracketing      | LithBoonkkampIJzermanBracket | ``2.91``               | ``3``   | ``1.427\dots``                        |
 | Robust          | King                         | ``\varphi=1.618\dots`` | ``2``   | ``1.272\dots``                        |
@@ -247,7 +251,7 @@ Identifying when an algorithm converges or diverges requires specifications of t
 
 In the case of exact bisection, convergence is mathematically
 guaranteed. For floating point numbers, either an *exact* zero is
-found, or the bracketing interval can be subdivided into ``[a_n,b_n]``
+found, or the bracketing interval can *not* be subdivided into ``[a_n,b_n]``
 with ``a_n`` and ``b_n`` being adjacent floating point values. That is
 ``b_n-a_n`` is as small as possible in floating point numbers. This can
 be considered a stopping criteria in ``\Delta x``. For early termination
@@ -263,7 +267,7 @@ determine closeness.
 Relying on the closeness of two ``x`` values will not be adequate for
 all problems, as there are examples where the difference
 ``\Delta_n=|x_n-x_{n-1}|`` can be quite small, ``0`` even, yet ``f(x_n)`` is
-not near a ``0``. As such, for non-bracketing methods, a check on the
+not near a ``0``. As well, a final step which should make $\Delta_n$ small enough, might get derailed due to floating point issues. As such, for non-bracketing methods and for some non-strict bracketing methods, a check on the
 size of ``f(x_n)`` is also used. As we find floating point
 approximations to ``\alpha``, the zero, we must consider values small
 when ``f(\alpha(1+\epsilon))`` is small. By Taylor's approximation, we
@@ -311,6 +315,7 @@ Roots.bisection
 Roots.muller
 Roots.newton
 Roots.dfree
+Roots.modab
 ```