Upload 256 files

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "mpmath/mcp_output/start_mcp.py"]

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "mpmath", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Mpmath MCP Service",
+    description="Auto-generated MCP service for mpmath",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Mpmath MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "mpmath MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

mpmath/mcp_output/README_MCP.md

@@ -0,0 +1,120 @@
+# mpmath MCP (Model Context Protocol) Service README
+
+## 1) Project Introduction
+
+This MCP (Model Context Protocol) service wraps the `mpmath` library to provide high-precision numerical computation for LLM/tool workflows.
+
+It is designed for:
+- Arbitrary-precision real/complex arithmetic
+- Numerical calculus (integration, differentiation, root finding)
+- Special functions (zeta, Bessel, elliptic, etc.)
+- Matrix and linear algebra operations
+- Optional interval arithmetic for enclosure-safe results
+
+Repository: https://github.com/fredrik-johansson/mpmath
+
+---
+
+## 2) Installation Method
+
+### Requirements
+- Python `>=3.8`
+- Required: `mpmath`
+- Optional:
+  - `gmpy2` (faster big-number backend in some workloads)
+  - `matplotlib` (plotting/visualization scenarios)
+
+### Install
+pip install mpmath
+
+Optional extras:
+pip install gmpy2 matplotlib
+
+---
+
+## 3) Quick Start
+
+### Basic usage
+import mpmath as mp
+mp.mp.dps = 50
+print(mp.sqrt(2))
+print(mp.zeta(3))
+print(mp.quad(lambda x: mp.sin(x), [0, mp.pi]))
+
+### Root finding
+import mpmath as mp
+f = lambda x: mp.cos(x) - x
+root = mp.findroot(f, 0.7)
+print(root)
+
+### Matrix / linear algebra
+import mpmath as mp
+A = mp.matrix([[1, 2], [3, 4]])
+print(A**-1)
+print(mp.det(A))
+
+### CLI mode
+python -m mpmath
+
+---
+
+## 4) Available Tools and Endpoints List
+
+Recommended MCP (Model Context Protocol) service endpoints (developer-oriented mapping to `mpmath` APIs):
+
+- `set_precision(dps)`  
+  Set decimal precision (`mp.mp.dps`) for subsequent computations.
+
+- `evaluate(expression, dps?)`  
+  Evaluate a safe mathematical expression with high precision.
+
+- `compute_function(name, args, dps?)`  
+  Call elementary/special functions such as `sqrt`, `exp`, `log`, `sin`, `cos`, `zeta`, etc.
+
+- `integrate(function_expr, interval, method?)`  
+  Numerical integration via `quad`/related quadrature routines.
+
+- `differentiate(function_expr, x, order?)`  
+  Differentiation using `diff` and related helpers.
+
+- `find_root(function_expr, x0, x1?)`  
+  Root solving via `findroot`.
+
+- `linear_algebra(operation, matrix, extra?)`  
+  Operations like `det`, `inverse`, `lu`, `qr`, `svd`, `cond`.
+
+- `interval_compute(name, args, dps?)`  
+  Interval arithmetic via `iv` context (`mpi`, interval-safe transforms).
+
+- `constants(name, dps?)`  
+  Return constants (`pi`, `e`, etc.) at configured precision.
+
+Notes:
+- Prefer stateless endpoint design: precision passed per request when possible.
+- Validate expression inputs carefully (avoid arbitrary code execution).
+
+---
+
+## 5) Common Issues and Notes
+
+- Precision vs performance: higher `dps` increases CPU/memory cost.
+- Convergence sensitivity: `findroot`, oscillatory integrals, and special functions may require better initial guesses or tuned precision.
+- Numerical stability: consider interval arithmetic (`iv`) for rigorous bounds.
+- Backend differences: availability of `gmpy2` can affect speed and behavior.
+- Serialization: return numeric outputs as strings for very high precision to avoid float truncation.
+- Security: never directly `eval` untrusted expressions without strict parsing/sandboxing.
+
+---
+
+## 6) Reference Links / Documentation
+
+- Main repository: https://github.com/fredrik-johansson/mpmath
+- Package docs/source tree (in repo): `docs/`, `mpmath/function_docs.py`
+- CLI entry: `python -m mpmath`
+- Core modules of interest:
+  - `mpmath.ctx_mp` (arbitrary precision context)
+  - `mpmath.calculus.quadrature` (integration)
+  - `mpmath.calculus.optimization` (root finding)
+  - `mpmath.calculus.differentiation` (derivatives/Taylor)
+  - `mpmath.matrices.linalg` (linear algebra)
+  - `mpmath.functions.*` (special functions)

mpmath/mcp_output/analysis.json

@@ -0,0 +1,720 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/fredrik-johansson/mpmath",
+    "summary": "Imported via zip fallback, file count: 155",
+    "file_tree": {
+      ".codecov.yml": {
+        "size": 159
+      },
+      ".github/dependabot.yml": {
+        "size": 215
+      },
+      ".github/workflows/coverage.yml": {
+        "size": 1489
+      },
+      ".github/workflows/docs.yml": {
+        "size": 1105
+      },
+      ".github/workflows/linter.yml": {
+        "size": 414
+      },
+      ".github/workflows/publish.yml": {
+        "size": 885
+      },
+      ".github/workflows/test.yml": {
+        "size": 1606
+      },
+      ".readthedocs.yaml": {
+        "size": 350
+      },
+      "conftest.py": {
+        "size": 647
+      },
+      "demo/mandelbrot.py": {
+        "size": 699
+      },
+      "demo/manydigits.py": {
+        "size": 2442
+      },
+      "demo/pidigits.py": {
+        "size": 2415
+      },
+      "demo/plotting.py": {
+        "size": 885
+      },
+      "demo/sofa.py": {
+        "size": 1824
+      },
+      "demo/taylor.py": {
+        "size": 2008
+      },
+      "docs/conf.py": {
+        "size": 1717
+      },
+      "docs/plots/ai.py": {
+        "size": 199
+      },
+      "docs/plots/ai_c.py": {
+        "size": 87
+      },
+      "docs/plots/ber.py": {
+        "size": 200
+      },
+      "docs/plots/besseli.py": {
+        "size": 209
+      },
+      "docs/plots/besseli_c.py": {
+        "size": 115
+      },
+      "docs/plots/besselj.py": {
+        "size": 195
+      },
+      "docs/plots/besselj_c.py": {
+        "size": 106
+      },
+      "docs/plots/besselk.py": {
+        "size": 221
+      },
+      "docs/plots/besselk_c.py": {
+        "size": 127
+      },
+      "docs/plots/bessely.py": {
+        "size": 214
+      },
+      "docs/plots/bessely_c.py": {
+        "size": 118
+      },
+      "docs/plots/bi.py": {
+        "size": 207
+      },
+      "docs/plots/bi_c.py": {
+        "size": 87
+      },
+      "docs/plots/buildplots.py": {
+        "size": 701
+      },
+      "docs/plots/chebyt.py": {
+        "size": 222
+      },
+      "docs/plots/chebyu.py": {
+        "size": 222
+      },
+      "docs/plots/coulombf.py": {
+        "size": 270
+      },
+      "docs/plots/coulombf_c.py": {
+        "size": 100
+      },
+      "docs/plots/coulombg.py": {
+        "size": 268
+      },
+      "docs/plots/coulombg_c.py": {
+        "size": 102
+      },
+      "docs/plots/ellipe.py": {
+        "size": 223
+      },
+      "docs/plots/ellipf.py": {
+        "size": 227
+      },
+      "docs/plots/ellipk.py": {
+        "size": 94
+      },
+      "docs/plots/ellippi.py": {
+        "size": 262
+      },
+      "docs/plots/gi.py": {
+        "size": 97
+      },
+      "docs/plots/gi_c.py": {
+        "size": 91
+      },
+      "docs/plots/hankel1.py": {
+        "size": 202
+      },
+      "docs/plots/hankel1_c.py": {
+        "size": 107
+      },
+      "docs/plots/hankel2.py": {
+        "size": 202
+      },
+      "docs/plots/hankel2_c.py": {
+        "size": 107
+      },
+      "docs/plots/hermite.py": {
+        "size": 241
+      },
+      "docs/plots/hi.py": {
+        "size": 103
+      },
+      "docs/plots/hi_c.py": {
+        "size": 91
+      },
+      "docs/plots/ker.py": {
+        "size": 197
+      },
+      "docs/plots/kleinj.py": {
+        "size": 128
+      },
+      "docs/plots/kleinj2.py": {
+        "size": 124
+      },
+      "docs/plots/laguerre.py": {
+        "size": 256
+      },
+      "docs/plots/lambertw.py": {
+        "size": 118
+      },
+      "docs/plots/lambertw_c.py": {
+        "size": 96
+      },
+      "docs/plots/legendre.py": {
+        "size": 231
+      },
+      "docs/plots/lommels1.py": {
+        "size": 229
+      },
+      "docs/plots/lommels2.py": {
+        "size": 241
+      },
+      "docs/plots/pcfd.py": {
+        "size": 225
+      },
+      "docs/plots/spherharm40.py": {
+        "size": 557
+      },
+      "docs/plots/spherharm41.py": {
+        "size": 337
+      },
+      "docs/plots/spherharm42.py": {
+        "size": 337
+      },
+      "docs/plots/spherharm43.py": {
+        "size": 337
+      },
+      "docs/plots/spherharm44.py": {
+        "size": 396
+      },
+      "mpmath/__init__.py": {
+        "size": 8474
+      },
+      "mpmath/__main__.py": {
+        "size": 6465
+      },
+      "mpmath/_interactive.py": {
+        "size": 3089
+      },
+      "mpmath/calculus/__init__.py": {
+        "size": 162
+      },
+      "mpmath/calculus/approximation.py": {
+        "size": 9057
+      },
+      "mpmath/calculus/calculus.py": {
+        "size": 104
+      },
+      "mpmath/calculus/differentiation.py": {
+        "size": 20366
+      },
+      "mpmath/calculus/extrapolation.py": {
+        "size": 73176
+      },
+      "mpmath/calculus/inverselaplace.py": {
+        "size": 33880
+      },
+      "mpmath/calculus/odes.py": {
+        "size": 9877
+      },
+      "mpmath/calculus/optimization.py": {
+        "size": 33079
+      },
+      "mpmath/calculus/polynomials.py": {
+        "size": 8216
+      },
+      "mpmath/calculus/quadrature.py": {
+        "size": 42720
+      },
+      "mpmath/ctx_base.py": {
+        "size": 16843
+      },
+      "mpmath/ctx_fp.py": {
+        "size": 7757
+      },
+      "mpmath/ctx_iv.py": {
+        "size": 17221
+      },
+      "mpmath/ctx_mp.py": {
+        "size": 49331
+      },
+      "mpmath/ctx_mp_python.py": {
+        "size": 43930
+      },
+      "mpmath/function_docs.py": {
+        "size": 296717
+      },
+      "mpmath/functions/__init__.py": {
+        "size": 330
+      },
+      "mpmath/functions/bessel.py": {
+        "size": 39965
+      },
+      "mpmath/functions/elliptic.py": {
+        "size": 43539
+      },
+      "mpmath/functions/expintegrals.py": {
+        "size": 11947
+      },
+      "mpmath/functions/factorials.py": {
+        "size": 5150
+      },
+      "mpmath/functions/functions.py": {
+        "size": 21038
+      },
+      "mpmath/functions/hypergeometric.py": {
+        "size": 53702
+      },
+      "mpmath/functions/orthogonal.py": {
+        "size": 16487
+      },
+      "mpmath/functions/qfunctions.py": {
+        "size": 7831
+      },
+      "mpmath/functions/rszeta.py": {
+        "size": 46176
+      },
+      "mpmath/functions/signals.py": {
+        "size": 703
+      },
+      "mpmath/functions/theta.py": {
+        "size": 37320
+      },
+      "mpmath/functions/zeta.py": {
+        "size": 36701
+      },
+      "mpmath/functions/zetazeros.py": {
+        "size": 30372
+      },
+      "mpmath/identification.py": {
+        "size": 29377
+      },
+      "mpmath/libfp.py": {
+        "size": 14932
+      },
+      "mpmath/libmp/__init__.py": {
+        "size": 4869
+      },
+      "mpmath/libmp/backend.py": {
+        "size": 1654
+      },
+      "mpmath/libmp/gammazeta.py": {
+        "size": 71789
+      },
+      "mpmath/libmp/libelefun.py": {
+        "size": 44672
+      },
+      "mpmath/libmp/libhyper.py": {
+        "size": 35987
+      },
+      "mpmath/libmp/libintmath.py": {
+        "size": 14329
+      },
+      "mpmath/libmp/libmpc.py": {
+        "size": 27811
+      },
+      "mpmath/libmp/libmpf.py": {
+        "size": 57756
+      },
+      "mpmath/libmp/libmpi.py": {
+        "size": 27630
+      },
+      "mpmath/matrices/__init__.py": {
+        "size": 94
+      },
+      "mpmath/matrices/calculus.py": {
+        "size": 18988
+      },
+      "mpmath/matrices/eigen.py": {
+        "size": 24129
+      },
+      "mpmath/matrices/eigen_symmetric.py": {
+        "size": 57985
+      },
+      "mpmath/matrices/linalg.py": {
+        "size": 31900
+      },
+      "mpmath/matrices/matrices.py": {
+        "size": 33913
+      },
+      "mpmath/tests/test_basic_ops.py": {
+        "size": 23738
+      },
+      "mpmath/tests/test_bitwise.py": {
+        "size": 7991
+      },
+      "mpmath/tests/test_calculus.py": {
+        "size": 11523
+      },
+      "mpmath/tests/test_cli.py": {
+        "size": 4892
+      },
+      "mpmath/tests/test_compatibility.py": {
+        "size": 2293
+      },
+      "mpmath/tests/test_convert.py": {
+        "size": 12373
+      },
+      "mpmath/tests/test_demos.py": {
+        "size": 4386
+      },
+      "mpmath/tests/test_diff.py": {
+        "size": 2489
+      },
+      "mpmath/tests/test_division.py": {
+        "size": 6126
+      },
+      "mpmath/tests/test_eigen.py": {
+        "size": 4108
+      },
+      "mpmath/tests/test_eigen_symmetric.py": {
+        "size": 8647
+      },
+      "mpmath/tests/test_elliptic.py": {
+        "size": 26317
+      },
+      "mpmath/tests/test_extra_gamma.py": {
+        "size": 6030
+      },
+      "mpmath/tests/test_extra_zeta.py": {
+        "size": 933
+      },
+      "mpmath/tests/test_format.py": {
+        "size": 34478
+      },
+      "mpmath/tests/test_fp.py": {
+        "size": 96881
+      },
+      "mpmath/tests/test_functions.py": {
+        "size": 39289
+      },
+      "mpmath/tests/test_functions2.py": {
+        "size": 102669
+      },
+      "mpmath/tests/test_gammazeta.py": {
+        "size": 29030
+      },
+      "mpmath/tests/test_hp.py": {
+        "size": 10473
+      },
+      "mpmath/tests/test_identify.py": {
+        "size": 826
+      },
+      "mpmath/tests/test_interval.py": {
+        "size": 17640
+      },
+      "mpmath/tests/test_levin.py": {
+        "size": 5006
+      },
+      "mpmath/tests/test_linalg.py": {
+        "size": 11460
+      },
+      "mpmath/tests/test_matrices.py": {
+        "size": 9503
+      },
+      "mpmath/tests/test_module.py": {
+        "size": 391
+      },
+      "mpmath/tests/test_mpmath.py": {
+        "size": 189
+      },
+      "mpmath/tests/test_ode.py": {
+        "size": 1771
+      },
+      "mpmath/tests/test_pickle.py": {
+        "size": 400
+      },
+      "mpmath/tests/test_power.py": {
+        "size": 5184
+      },
+      "mpmath/tests/test_quad.py": {
+        "size": 4115
+      },
+      "mpmath/tests/test_rootfinding.py": {
+        "size": 3755
+      },
+      "mpmath/tests/test_special.py": {
+        "size": 2923
+      },
+      "mpmath/tests/test_str.py": {
+        "size": 1270
+      },
+      "mpmath/tests/test_summation.py": {
+        "size": 2069
+      },
+      "mpmath/tests/test_torture.py": {
+        "size": 9235
+      },
+      "mpmath/tests/test_trig.py": {
+        "size": 4854
+      },
+      "mpmath/tests/test_visualization.py": {
+        "size": 951
+      },
+      "mpmath/usertools.py": {
+        "size": 3067
+      },
+      "mpmath/visualization.py": {
+        "size": 10747
+      },
+      "pyproject.toml": {
+        "size": 2931
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.mpmath",
+      "source.mpmath.calculus",
+      "source.mpmath.functions",
+      "source.mpmath.libmp",
+      "source.mpmath.matrices"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.mpmath",
+        "module": "__init__",
+        "functions": [
+          "mp",
+          "fp",
+          "iv",
+          "workdps",
+          "workprec",
+          "extradps",
+          "extrabits",
+          "autoprec",
+          "memoize",
+          "maxcalls",
+          "monitor"
+        ],
+        "classes": [],
+        "description": "Primary public API surface exposing high-precision contexts and utility decorators/context managers."
+      },
+      {
+        "package": "source.mpmath",
+        "module": "ctx_mp",
+        "functions": [
+          "mpf",
+          "mpc",
+          "matrix",
+          "convert",
+          "chop",
+          "nstr",
+          "nprint",
+          "frac"
+        ],
+        "classes": [
+          "MPContext"
+        ],
+        "description": "Arbitrary-precision core context implementation used by most high-level numerical operations."
+      },
+      {
+        "package": "source.mpmath",
+        "module": "ctx_fp",
+        "functions": [
+          "sqrt",
+          "sin",
+          "cos",
+          "exp",
+          "log"
+        ],
+        "classes": [
+          "FPContext"
+        ],
+        "description": "Standard floating-point context with mpmath-compatible API for speed-oriented operations."
+      },
+      {
+        "package": "source.mpmath",
+        "module": "ctx_iv",
+        "functions": [
+          "mpi",
+          "sin",
+          "cos",
+          "exp",
+          "log"
+        ],
+        "classes": [
+          "IntervalContext"
+        ],
+        "description": "Interval arithmetic context providing enclosure-based numerical computation."
+      },
+      {
+        "package": "source.mpmath.calculus",
+        "module": "quadrature",
+        "functions": [
+          "quad",
+          "quadts",
+          "quadosc",
+          "quadgl"
+        ],
+        "classes": [],
+        "description": "Numerical integration routines (adaptive, oscillatory, Gaussian-style interfaces)."
+      },
+      {
+        "package": "source.mpmath.calculus",
+        "module": "optimization",
+        "functions": [
+          "findroot",
+          "multiplicity",
+          "steffensen"
+        ],
+        "classes": [],
+        "description": "Root-finding and nonlinear optimization utilities."
+      },
+      {
+        "package": "source.mpmath.calculus",
+        "module": "differentiation",
+        "functions": [
+          "diff",
+          "diffs",
+          "diffun",
+          "taylor"
+        ],
+        "classes": [],
+        "description": "Differentiation and series expansion helpers."
+      },
+      {
+        "package": "source.mpmath.functions",
+        "module": "functions",
+        "functions": [
+          "sqrt",
+          "exp",
+          "ln",
+          "log",
+          "power",
+          "sin",
+          "cos",
+          "tan"
+        ],
+        "classes": [],
+        "description": "Elementary/special function dispatch layer shared by contexts."
+      },
+      {
+        "package": "source.mpmath.functions",
+        "module": "zeta",
+        "functions": [
+          "zeta",
+          "altzeta",
+          "primezeta",
+          "riemannr",
+          "siegeltheta",
+          "grampoint"
+        ],
+        "classes": [],
+        "description": "Zeta-family and analytic number theory functions."
+      },
+      {
+        "package": "source.mpmath.matrices",
+        "module": "linalg",
+        "functions": [
+          "lu",
+          "qr",
+          "svd",
+          "inverse",
+          "det",
+          "cond"
+        ],
+        "classes": [],
+        "description": "Linear algebra decomposition and solve routines."
+      },
+      {
+        "package": "source.mpmath.matrices",
+        "module": "matrices",
+        "functions": [
+          "matrix",
+          "eye",
+          "zeros",
+          "ones",
+          "diag",
+          "hilbert"
+        ],
+        "classes": [
+          "matrix"
+        ],
+        "description": "Matrix construction/manipulation primitives and matrix type implementation."
+      },
+      {
+        "package": "source.mpmath.libmp",
+        "module": "libmpf",
+        "functions": [
+          "from_int",
+          "from_float",
+          "to_float",
+          "mpf_add",
+          "mpf_mul",
+          "mpf_div",
+          "mpf_pow_int"
+        ],
+        "classes": [],
+        "description": "Low-level arbitrary-precision real arithmetic backend."
+      }
+    ],
+    "cli_commands": [
+      {
+        "name": "python -m mpmath",
+        "module": "source.mpmath.__main__",
+        "description": "Launches mpmath interactive shell/REPL-style interface for evaluating expressions with arbitrary precision."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "cli",
+      "confidence": 0.95
+    },
+    "dependencies": {
+      "required": [
+        "python>=3.8"
+      ],
+      "optional": [
+        "gmpy2",
+        "matplotlib"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.95,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/fredrik-johansson/mpmath",
+    "repo_name": "mpmath",
+    "error": "DeepWiki analysis failed",
+    "model": "gpt-5.3-codex",
+    "source": "llm_direct_analysis",
+    "success": false
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-5.3-codex"
+  },
+  "risk": {
+    "import_feasibility": 0.95,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

mpmath/mcp_output/diff_report.md

@@ -0,0 +1,161 @@
+# Difference Report — `mpmath`
+
+**Generated:** 2026-03-12 03:31:00  
+**Repository:** `mpmath`  
+**Project Type:** Python library  
+**Feature Scope:** Basic functionality  
+**Intrusiveness:** None  
+**Workflow Status:** ✅ Success  
+**Test Status:** ❌ Failed  
+**Changed Files:** `8 new`, `0 modified`
+
+---
+
+## 1) Executive Summary
+
+This update introduces **8 new files** with **no direct modifications** to existing files, indicating a likely additive, low-risk change set at the source level.  
+However, despite successful workflow execution, the **test suite failed**, which is the primary blocker for release readiness.
+
+**Current release recommendation:** **Do not release** until test failures are resolved and validated.
+
+---
+
+## 2) Project Overview
+
+`mpmath` is a Python numerical library focused on arbitrary-precision arithmetic and special mathematical functions.  
+Given the stated scope (“Basic functionality”), this change likely targets foundational additions (e.g., utilities, docs, configuration, tests, or auxiliary modules) rather than deep architectural refactors.
+
+---
+
+## 3) Change Inventory
+
+| Metric | Value |
+|---|---|
+| New files | 8 |
+| Modified files | 0 |
+| Deleted files | 0 (not reported) |
+| Intrusiveness | None |
+| CI/Workflow | Success |
+| Tests | Failed |
+
+### Interpretation
+- **No in-place edits** reduce regression risk in existing code paths.
+- **New-file-only change pattern** often implies extensibility work, packaging/test additions, docs, or new modules.
+- **Failed tests** suggest either:
+  1. New code introduces failing expectations,
+  2. Environment/dependency drift,
+  3. Incomplete integration of newly added files.
+
+---
+
+## 4) Difference Analysis
+
+## 4.1 Structural Impact
+- Additive update with no direct mutation of existing implementation files.
+- Potentially clean separation, but practical impact depends on whether new files are imported/executed by runtime or test discovery.
+
+## 4.2 Functional Impact (Expected)
+- Since the feature scope is basic, likely impact includes:
+  - foundational helpers,
+  - baseline API extension,
+  - test/data fixture introduction,
+  - packaging or project metadata support.
+- No evidence of intrusive behavior or broad refactor.
+
+## 4.3 Risk Profile
+- **Source risk:** Low (additive, non-intrusive).
+- **Integration risk:** Medium (test failures indicate unresolved compatibility or correctness issue).
+- **Release risk:** High until tests pass.
+
+---
+
+## 5) Technical Analysis
+
+## 5.1 CI vs Test Paradox
+Workflow success with failed tests typically means:
+- pipeline completed execution correctly,
+- but one or more validation gates failed.
+
+This is usually healthy CI behavior and indicates reliable signaling.
+
+## 5.2 Likely Failure Domains
+Given new-file-only changes, investigate:
+1. **Test discovery conflicts** (naming, duplicate test modules, unintended collection).
+2. **Import path issues** (new modules not on path, circular imports).
+3. **Dependency/version constraints** (new file requires package absent in CI matrix).
+4. **Baseline assumptions** (precision defaults, platform-specific numeric behavior).
+5. **Configuration drift** (`pyproject.toml`, `setup.cfg`, `tox.ini`, `pytest.ini` additions not aligned).
+
+## 5.3 Quality Gate Status
+- Build/Workflow orchestration: **Pass**
+- Verification/Tests: **Fail**
+- Overall quality gate: **Fail**
+
+---
+
+## 6) Recommendations & Improvements
+
+## 6.1 Immediate (Blocking) Actions
+1. **Triage failing tests by class**
+   - deterministic logic failure vs environment/setup failure.
+2. **Reproduce locally using CI-equivalent environment**
+   - same Python versions, dependency pins, and test command.
+3. **Isolate impact of each new file**
+   - disable selectively to identify triggering artifact.
+4. **Patch and rerun full suite**
+   - include targeted + full regression runs.
+
+## 6.2 Short-Term Hardening
+- Add/adjust:
+  - explicit dependency pins/markers,
+  - import smoke tests for newly added modules,
+  - stricter lint/type checks on new files.
+- Ensure test files follow consistent discovery naming conventions.
+- Validate packaging manifests include/exclude new files correctly.
+
+## 6.3 Process Improvements
+- Require **green tests** as merge gate.
+- Add CI matrix checks for supported Python versions and OSes.
+- Introduce a pre-merge “new-file sanity checklist”:
+  - importability,
+  - docs coverage,
+  - tests for each new public symbol.
+
+---
+
+## 7) Deployment Information
+
+## 7.1 Readiness
+- **Not deployment-ready** due to failed tests.
+
+## 7.2 Suggested Deployment Decision
+- **Hold release**.
+- Create a hotfix/patch branch to resolve failures.
+- Re-run CI and only proceed when:
+  - full test suite passes,
+  - no regressions observed in numerical core scenarios.
+
+## 7.3 Rollback Consideration
+- Since no files were modified, rollback complexity is low (revert additive changeset if needed).
+
+---
+
+## 8) Future Planning
+
+1. **Stability-first milestone**
+   - close all current test failures,
+   - add regression tests capturing root cause.
+2. **Observability**
+   - improve CI logs/artifacts for quicker failure localization.
+3. **Compatibility roadmap**
+   - formalize version support and dependency strategy.
+4. **Incremental release policy**
+   - small additive batches with mandatory green gates before tagging releases.
+
+---
+
+## 9) Conclusion
+
+The update is structurally low-intrusive (8 new files, no modified files) but currently **blocked by failing tests**.  
+From an engineering governance perspective, this is a **non-releasable state**.  
+Resolve test failures, strengthen integration checks for newly added artifacts, and rerun full validation prior to deployment.

mpmath/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,325 @@
+import os
+import sys
+import traceback
+import importlib
+from typing import Any, Dict, Optional, List
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+sys.path.insert(0, source_path)
+
+
+class Adapter:
+    """
+    MCP Import Mode Adapter for mpmath repository.
+
+    This adapter prioritizes direct Python import usage from local source code and provides
+    graceful fallback guidance if imports fail.
+
+    Unified return format:
+        {
+            "status": "success" | "error" | "fallback",
+            "mode": "import" | "fallback",
+            "data": Any,
+            "error": str | None,
+            "guidance": str | None
+        }
+    """
+
+    # -------------------------------------------------------------------------
+    # Initialization and module management
+    # -------------------------------------------------------------------------
+    def __init__(self) -> None:
+        self.mode = "import"
+        self._modules: Dict[str, Any] = {}
+        self._import_error: Optional[str] = None
+        self._load_modules()
+
+    def _result(
+        self,
+        status: str,
+        data: Any = None,
+        error: Optional[str] = None,
+        guidance: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return {
+            "status": status,
+            "mode": self.mode,
+            "data": data,
+            "error": error,
+            "guidance": guidance,
+        }
+
+    def _load_modules(self) -> None:
+        module_map = {
+            "mpmath": "mpmath",
+            "interactive": "mpmath._interactive",
+            "main": "mpmath.__main__",
+            "ctx_base": "mpmath.ctx_base",
+            "ctx_fp": "mpmath.ctx_fp",
+            "ctx_iv": "mpmath.ctx_iv",
+            "ctx_mp": "mpmath.ctx_mp",
+            "ctx_mp_python": "mpmath.ctx_mp_python",
+            "function_docs": "mpmath.function_docs",
+            "identification": "mpmath.identification",
+            "libfp": "mpmath.libfp",
+            "usertools": "mpmath.usertools",
+            "visualization": "mpmath.visualization",
+            "calculus_approximation": "mpmath.calculus.approximation",
+            "calculus_differentiation": "mpmath.calculus.differentiation",
+            "calculus_extrapolation": "mpmath.calculus.extrapolation",
+            "calculus_inverselaplace": "mpmath.calculus.inverselaplace",
+            "calculus_odes": "mpmath.calculus.odes",
+            "calculus_optimization": "mpmath.calculus.optimization",
+            "calculus_polynomials": "mpmath.calculus.polynomials",
+            "calculus_quadrature": "mpmath.calculus.quadrature",
+            "functions_bessel": "mpmath.functions.bessel",
+            "functions_elliptic": "mpmath.functions.elliptic",
+            "functions_expintegrals": "mpmath.functions.expintegrals",
+            "functions_factorials": "mpmath.functions.factorials",
+            "functions_functions": "mpmath.functions.functions",
+            "functions_hypergeometric": "mpmath.functions.hypergeometric",
+            "functions_orthogonal": "mpmath.functions.orthogonal",
+            "functions_qfunctions": "mpmath.functions.qfunctions",
+            "functions_rszeta": "mpmath.functions.rszeta",
+            "functions_signals": "mpmath.functions.signals",
+            "functions_theta": "mpmath.functions.theta",
+            "functions_zeta": "mpmath.functions.zeta",
+            "functions_zetazeros": "mpmath.functions.zetazeros",
+            "libmp_backend": "mpmath.libmp.backend",
+            "libmp_gammazeta": "mpmath.libmp.gammazeta",
+            "libmp_libelefun": "mpmath.libmp.libelefun",
+            "libmp_libhyper": "mpmath.libmp.libhyper",
+            "libmp_libintmath": "mpmath.libmp.libintmath",
+            "libmp_libmpc": "mpmath.libmp.libmpc",
+            "libmp_libmpf": "mpmath.libmp.libmpf",
+            "libmp_libmpi": "mpmath.libmp.libmpi",
+            "matrices_calculus": "mpmath.matrices.calculus",
+            "matrices_eigen": "mpmath.matrices.eigen",
+            "matrices_eigen_symmetric": "mpmath.matrices.eigen_symmetric",
+            "matrices_linalg": "mpmath.matrices.linalg",
+            "matrices_matrices": "mpmath.matrices.matrices",
+        }
+
+        try:
+            for key, mod_path in module_map.items():
+                self._modules[key] = importlib.import_module(mod_path)
+            self.mode = "import"
+            self._import_error = None
+        except Exception as exc:
+            self.mode = "fallback"
+            self._import_error = f"Import failed: {exc}"
+            self._modules = {}
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Check adapter readiness and dependency status.
+        """
+        if self.mode == "import":
+            return self._result(
+                "success",
+                data={
+                    "import_mode": True,
+                    "repository": "mpmath",
+                    "python_requirement": ">=3.8",
+                    "optional_dependencies": ["gmpy2", "matplotlib"],
+                    "loaded_modules": sorted(list(self._modules.keys())),
+                },
+            )
+        return self._result(
+            "fallback",
+            data={"import_mode": False},
+            error=self._import_error,
+            guidance=(
+                "Ensure repository source is available under './source' and retry. "
+                "You can also run CLI fallback with 'python -m mpmath'."
+            ),
+        )
+
+    # -------------------------------------------------------------------------
+    # Generic execution helpers
+    # -------------------------------------------------------------------------
+    def call_mpmath(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call a top-level function or access object from mpmath package.
+
+        Parameters:
+            function_name: Name of attribute/function in 'mpmath'.
+            *args/**kwargs: Forwarded to callable targets.
+
+        Returns:
+            Unified status dictionary with function result.
+        """
+        if self.mode != "import":
+            return self._result(
+                "fallback",
+                error=self._import_error,
+                guidance="Import mode unavailable. Use 'python -m mpmath' for interactive CLI fallback.",
+            )
+        try:
+            mpmath_mod = self._modules["mpmath"]
+            target = getattr(mpmath_mod, function_name)
+            if callable(target):
+                return self._result("success", data=target(*args, **kwargs))
+            return self._result("success", data=target)
+        except AttributeError:
+            return self._result(
+                "error",
+                error=f"Function or attribute '{function_name}' was not found in mpmath.",
+                guidance="Check function name spelling and confirm it exists in the repository version.",
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Failed to execute mpmath.{function_name}: {exc}",
+                guidance="Validate input arguments and numeric domains for the selected operation.",
+            )
+
+    def call_module_function(
+        self, module_key: str, function_name: str, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        """
+        Call a function dynamically from any loaded module.
+
+        Parameters:
+            module_key: Internal loaded module key (see health_check loaded_modules).
+            function_name: Target function or attribute name.
+            *args/**kwargs: Forwarded to callable targets.
+
+        Returns:
+            Unified status dictionary with call result.
+        """
+        if self.mode != "import":
+            return self._result(
+                "fallback",
+                error=self._import_error,
+                guidance="Import mode unavailable. Ensure source path is correct and retry.",
+            )
+        try:
+            mod = self._modules[module_key]
+            target = getattr(mod, function_name)
+            if callable(target):
+                return self._result("success", data=target(*args, **kwargs))
+            return self._result("success", data=target)
+        except KeyError:
+            return self._result(
+                "error",
+                error=f"Module key '{module_key}' is not loaded.",
+                guidance="Use health_check to inspect available module keys.",
+            )
+        except AttributeError:
+            return self._result(
+                "error",
+                error=f"Function or attribute '{function_name}' was not found in module '{module_key}'.",
+                guidance="Inspect module API and ensure the requested symbol exists.",
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Failed to execute {module_key}.{function_name}: {exc}",
+                guidance="Check the function signature and argument compatibility.",
+            )
+
+    # -------------------------------------------------------------------------
+    # CLI fallback support
+    # -------------------------------------------------------------------------
+    def run_cli_entry(self, argv: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Run repository CLI entry equivalent to `python -m mpmath`.
+
+        Parameters:
+            argv: Optional argv list (without program name). If omitted, empty list is used.
+
+        Returns:
+            Unified status dictionary.
+        """
+        try:
+            main_mod = importlib.import_module("mpmath.__main__")
+            if hasattr(main_mod, "main") and callable(main_mod.main):
+                result = main_mod.main(*(argv or []))
+                return self._result("success", data=result)
+            return self._result(
+                "error",
+                error="CLI module loaded, but no callable 'main' entry was found.",
+                guidance="Use 'python -m mpmath' directly if module-level execution is required.",
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"CLI execution failed: {exc}",
+                guidance="Run 'python -m mpmath' in a shell to inspect interactive startup behavior.",
+            )
+
+    # -------------------------------------------------------------------------
+    # Class instance helpers (generic, for identified modules)
+    # -------------------------------------------------------------------------
+    def create_instance(
+        self, module_key: str, class_name: str, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        """
+        Create an instance from a class in a loaded module.
+
+        Parameters:
+            module_key: Internal loaded module key.
+            class_name: Class name inside the module.
+            *args/**kwargs: Constructor arguments.
+
+        Returns:
+            Unified status dictionary with created instance.
+        """
+        if self.mode != "import":
+            return self._result(
+                "fallback",
+                error=self._import_error,
+                guidance="Import mode unavailable. Verify local source layout and retry.",
+            )
+        try:
+            mod = self._modules[module_key]
+            cls = getattr(mod, class_name)
+            instance = cls(*args, **kwargs)
+            return self._result("success", data=instance)
+        except KeyError:
+            return self._result(
+                "error",
+                error=f"Module key '{module_key}' is not loaded.",
+                guidance="Check available modules via health_check.",
+            )
+        except AttributeError:
+            return self._result(
+                "error",
+                error=f"Class '{class_name}' does not exist in module '{module_key}'.",
+                guidance="Confirm class name and module selection.",
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Failed to instantiate {module_key}.{class_name}: {exc}",
+                guidance="Review constructor parameters and required types.",
+            )
+
+    # -------------------------------------------------------------------------
+    # Convenience wrappers for major module groups
+    # -------------------------------------------------------------------------
+    def call_calculus(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return self.call_mpmath(function_name, *args, **kwargs)
+
+    def call_functions(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return self.call_mpmath(function_name, *args, **kwargs)
+
+    def call_matrices(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return self.call_mpmath(function_name, *args, **kwargs)
+
+    def get_traceback(self) -> Dict[str, Any]:
+        """
+        Return current traceback string if called inside exception context.
+        """
+        try:
+            return self._result("success", data=traceback.format_exc())
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Failed to capture traceback: {exc}",
+                guidance="Call this method from within an active exception handling context.",
+            )

mpmath/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

mpmath/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,242 @@
+import os
+import sys
+from typing import List
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+import mpmath as mp
+
+mcp = FastMCP("mpmath_service")
+
+
+@mcp.tool(name="set_precision", description="Set global decimal precision for mpmath calculations.")
+def set_precision(dps: int) -> dict:
+    """
+    Set mpmath decimal precision.
+
+    Parameters:
+        dps: Number of decimal digits to keep in mpmath.mp.dps.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        if dps < 2:
+            raise ValueError("dps must be >= 2")
+        mp.mp.dps = dps
+        return {"success": True, "result": {"dps": mp.mp.dps}, "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="evaluate_expression", description="Evaluate a mathematical expression using mpmath context.")
+def evaluate_expression(expression: str) -> dict:
+    """
+    Evaluate a Python expression with mpmath symbols available.
+
+    Parameters:
+        expression: Expression string, e.g. 'sin(pi/3) + sqrt(2)'.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        safe_globals = {"__builtins__": {}}
+        safe_locals = {name: getattr(mp, name) for name in dir(mp) if not name.startswith("_")}
+        value = eval(expression, safe_globals, safe_locals)
+        return {"success": True, "result": str(value), "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="find_root", description="Find a root of a function using mpmath.findroot.")
+def find_root(function_expression: str, x0: float) -> dict:
+    """
+    Find a numeric root for a single-variable function.
+
+    Parameters:
+        function_expression: Expression in variable x, e.g. 'cos(x)-x'.
+        x0: Initial guess.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        safe_globals = {"__builtins__": {}}
+        safe_locals = {name: getattr(mp, name) for name in dir(mp) if not name.startswith("_")}
+
+        def f(x):
+            local_ctx = dict(safe_locals)
+            local_ctx["x"] = x
+            return eval(function_expression, safe_globals, local_ctx)
+
+        root = mp.findroot(f, x0)
+        return {"success": True, "result": str(root), "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="integrate", description="Compute definite integral using mpmath.quad.")
+def integrate(function_expression: str, a: float, b: float) -> dict:
+    """
+    Compute definite integral of f(x) from a to b.
+
+    Parameters:
+        function_expression: Expression in variable x, e.g. 'exp(-x**2)'.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        safe_globals = {"__builtins__": {}}
+        safe_locals = {name: getattr(mp, name) for name in dir(mp) if not name.startswith("_")}
+
+        def f(x):
+            local_ctx = dict(safe_locals)
+            local_ctx["x"] = x
+            return eval(function_expression, safe_globals, local_ctx)
+
+        val = mp.quad(f, [a, b])
+        return {"success": True, "result": str(val), "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="differentiate", description="Compute n-th derivative at a point using mpmath.diff.")
+def differentiate(function_expression: str, x: float, n: int) -> dict:
+    """
+    Compute derivative of order n for f at x.
+
+    Parameters:
+        function_expression: Expression in variable t, e.g. 'sin(t)*exp(t)'.
+        x: Evaluation point.
+        n: Derivative order (>=1).
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        if n < 1:
+            raise ValueError("n must be >= 1")
+        safe_globals = {"__builtins__": {}}
+        safe_locals = {name: getattr(mp, name) for name in dir(mp) if not name.startswith("_")}
+
+        def f(t):
+            local_ctx = dict(safe_locals)
+            local_ctx["t"] = t
+            return eval(function_expression, safe_globals, local_ctx)
+
+        val = mp.diff(f, x, n=n)
+        return {"success": True, "result": str(val), "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="solve_linear_system", description="Solve a dense linear system A*x=b with mpmath matrices.")
+def solve_linear_system(a_rows: List[List[float]], b_values: List[float]) -> dict:
+    """
+    Solve linear system A*x=b.
+
+    Parameters:
+        a_rows: Matrix rows for A.
+        b_values: Vector b.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        if len(a_rows) == 0:
+            raise ValueError("a_rows must not be empty")
+        if len(a_rows) != len(b_values):
+            raise ValueError("A row count must match b length")
+        col_count = len(a_rows[0])
+        if col_count == 0:
+            raise ValueError("A must have at least one column")
+        for row in a_rows:
+            if len(row) != col_count:
+                raise ValueError("All rows in A must have same length")
+
+        A = mp.matrix(a_rows)
+        b = mp.matrix([[v] for v in b_values])
+        x = mp.lu_solve(A, b)
+        result = [str(x[i]) for i in range(len(b_values))]
+        return {"success": True, "result": result, "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="eigenvalues", description="Compute eigenvalues of a square matrix.")
+def eigenvalues(matrix_rows: List[List[float]]) -> dict:
+    """
+    Compute eigenvalues of a square matrix.
+
+    Parameters:
+        matrix_rows: Square matrix rows.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        n = len(matrix_rows)
+        if n == 0:
+            raise ValueError("matrix_rows must not be empty")
+        for row in matrix_rows:
+            if len(row) != n:
+                raise ValueError("Matrix must be square")
+        M = mp.matrix(matrix_rows)
+        vals = mp.eig(M, left=False, right=False)
+        result = [str(v) for v in vals]
+        return {"success": True, "result": result, "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="special_function", description="Evaluate selected special functions from mpmath.")
+def special_function(function_name: str, x: float) -> dict:
+    """
+    Evaluate one supported special function at x.
+
+    Parameters:
+        function_name: One of ['gamma', 'zeta', 'erf', 'besselj0', 'bessely0', 'airyai', 'airybi'].
+        x: Input value.
+
+    Returns:
+        Dictionary with success/result/error.
+    """
+    try:
+        fn = function_name.lower().strip()
+        if fn == "gamma":
+            v = mp.gamma(x)
+        elif fn == "zeta":
+            v = mp.zeta(x)
+        elif fn == "erf":
+            v = mp.erf(x)
+        elif fn == "besselj0":
+            v = mp.besselj(0, x)
+        elif fn == "bessely0":
+            v = mp.bessely(0, x)
+        elif fn == "airyai":
+            v = mp.airyai(x)
+        elif fn == "airybi":
+            v = mp.airybi(x)
+        else:
+            raise ValueError("Unsupported function_name")
+        return {"success": True, "result": str(v), "error": ""}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+def create_app() -> FastMCP:
+    return mcp
+
+
+if __name__ == "__main__":
+    mcp.run()

mpmath/mcp_output/requirements.txt

@@ -0,0 +1,4 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0

mpmath/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

mpmath/mcp_output/workflow_summary.json

@@ -0,0 +1,237 @@
+{
+  "repository": {
+    "name": "mpmath",
+    "url": "https://github.com/fredrik-johansson/mpmath",
+    "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/mpmath",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1773257128.606097,
+    "end_time": 1773257334.291369,
+    "duration": 205.6852719783783,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 5,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.mpmath",
+        "source.mpmath.calculus",
+        "source.mpmath.functions",
+        "source.mpmath.libmp",
+        "source.mpmath.matrices"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": true,
+      "setup_cfg": false,
+      "setup_py": false
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.95,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/fredrik-johansson/mpmath",
+      "repo_name": "mpmath",
+      "error": "DeepWiki analysis failed",
+      "model": "gpt-5.3-codex",
+      "source": "llm_direct_analysis",
+      "success": false
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/mpmath/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "add CI test status reporting and badges (unit",
+    "coverage",
+    "docs) since current test status is empty",
+    "add MCP plugin smoke/integration tests under `mcp_output/tests_mcp` for key contexts (`mp`",
+    "`fp`",
+    "`iv`) and high-risk numerics (`findroot`",
+    "`quad`",
+    "`zeta`)",
+    "deduplicate/namespace MCP endpoints to avoid collisions (`sin`",
+    "`cos`",
+    "`exp`",
+    "`log`",
+    "`matrix` appear multiple times)",
+    "generate structured tool metadata (module/context/origin) for each exported endpoint to improve discoverability",
+    "add property-based numerical tests (e.g.",
+    "Hypothesis) for algebraic identities and interval enclosure invariants",
+    "expand edge-case regression tests for precision/context switching (`workdps`",
+    "`extradps`",
+    "`autoprec`) and cross-context consistency",
+    "enforce stricter static quality gates (ruff/flake8 + mypy on plugin code",
+    "optional gradual typing in core hotspots)",
+    "add performance benchmarks (asv/pytest-benchmark) for core kernels (`libmpf`",
+    "`gammazeta`",
+    "quadrature",
+    "linear algebra) with CI trend tracking",
+    "split very large modules (`function_docs.py`",
+    "`test_functions2.py`",
+    "`ctx_mp*.py`) into smaller maintainable units",
+    "document optional dependency behavior (`gmpy2`",
+    "`matplotlib`) with fallback/perf expectations",
+    "add API compatibility tests for `python -m mpmath` CLI and MCP adapter import mode",
+    "harden packaging/reproducibility by pinning MCP plugin dependency ranges and adding lockfile or constraints",
+    "improve docs automation by validating `docs/plots` scripts and ensuring deterministic plot builds in CI",
+    "add release safeguards (changelog validation",
+    "version/tag consistency checks",
+    "publish dry-run)",
+    "introduce security hygiene checks (pip-audit/Safety",
+    "GitHub dependency review)",
+    "add observability to MCP service (structured logging",
+    "request timing",
+    "failure categorization)",
+    "create contributor-facing architecture docs mapping contexts/functions/libmp layers and MCP exposure rules"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Workflow status is success with all planned nodes executed (download, analysis, env, generate, run, review, finalize).",
+      "Import-based adapter strategy is highly feasible for mpmath (import_feasibility 0.95, low intrusiveness risk).",
+      "Generated MCP plugin started healthy over stdio and passed plugin-level checks.",
+      "Repository structure and core modules were correctly discovered, enabling broad endpoint exposure."
+    ],
+    "failure_reasons": [
+      "No hard workflow failure occurred.",
+      "DeepWiki analysis failed (non-blocking), reducing external architectural/context enrichment.",
+      "Original project test execution is effectively absent despite reporting 100% coverage (passed=false, no test files, zero execution time), indicating a test instrumentation/reporting defect.",
+      "Generated artifact metrics are inconsistent (0 LOC/size/tools despite endpoint list), indicating telemetry/measurement pipeline issues."
+    ],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Completed successfully via zip fallback; reliable but likely slower/less metadata-rich than native VCS clone.",
+      "analysis_time": "Completed with medium-complexity repo analysis across ~155 files; module and package extraction quality is strong.",
+      "generation_time": "Completed and produced expected MCP scaffold files; endpoint extraction appears broad but metric reporting is inconsistent.",
+      "test_time": "Plugin health test passed quickly; original project tests did not run meaningfully, leaving functional confidence gap."
+    },
+    "resource_usage": {
+      "memory_efficiency": "Unknown in practice: reported memory usage is 0 MB, which indicates missing telemetry rather than true zero use.",
+      "cpu_efficiency": "Unknown in practice: reported CPU usage is 0%, likely uncollected metrics.",
+      "disk_usage": "Low-to-moderate expected for generated plugin files, but reported generated size is 0, indicating measurement gap."
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 76,
+    "architecture_score": 82,
+    "performance_score": 61,
+    "maintainability_score": 73,
+    "security_score": 85,
+    "scalability_score": 72
+  }
+}

mpmath/source/.codecov.yml

@@ -0,0 +1,11 @@
+coverage:
+  precision: 0
+  round: down
+  status:
+    patch:
+      default:
+        target: 97
+    project:
+      default:
+        threshold: 1%
+comment: false

mpmath/source/.readthedocs.yaml

@@ -0,0 +1,20 @@
+version: 2
+formats:
+    - htmlzip
+    - pdf
+build:
+    os: ubuntu-22.04
+    tools:
+        python: "3"
+    jobs:
+        post_checkout:
+            - git fetch --unshallow
+python:
+    install:
+        - method: pip
+          path: .
+          extra_requirements:
+              - docs
+sphinx:
+    fail_on_warning: true
+    configuration: docs/conf.py

mpmath/source/CHANGES

@@ -0,0 +1,1257 @@
+--1.4.0--
+Released February 23, 2026
+
+Features:
+
+* Support underscores as digit separators per PEP 515, see #661 (Sergey B
+  Kirpichev)
+* Add rationals converter for mpf's, see #666 (Sergey B Kirpichev)
+* Rewrite bernpoly/eulerpoly to avoid dependency on bernoulli(1) convention,
+  see #700 (Sergey B Kirpichev)
+* Support base kwarg for from_str(), see #703 (Jonathan Warner, Sergey B
+  Kirpichev)
+* Support randmatrix() for mp.iv and mp contexts, see #527 (Maximilian
+  Gaukler)
+* Added rank() function for matrices, see #610 (Jan-Philipp Hoffmann)
+* Add plus flag to select the B_1 sign convention for bernoulli/bernfrac, see
+  #724 (Jeremy Tan Jie Rui, Sergey B Kirpichev)
+* Add mpf.as_integer_ratio() method, support construction of mpf from Decimal
+  objects, see #731 (Sergey B Kirpichev)
+* Expose lower/upper_gamma functions, see #740 (Sergey B Kirpichev)
+* Support mpc initialization from string, see #743 (Sergey B Kirpichev)
+* Support asinh/acosh/atanh in the fp context, see #750 (Sergey B Kirpichev)
+* Support binary/octal/hexadecimal string output, see #711 (Jonathan Warner,
+  Sergey B Kirpichev)
+* Support pickling for matrices and mpi, see #761 (Sergey B Kirpichev)
+* Support matrix.__array__() dunder method, see #767 (Sergey B Kirpichev)
+* Support more number syntaxes, see #778 (Sergey B Kirpichev)
+* Run mpmath as a module for interactive work, see #773, #923, #931, #936,
+  #939 and #954 (Sergey B Kirpichev)
+* Add signed option to to_man_exp(), see #783 (Sergey B Kirpichev)
+* Add fp.hypot, see #798 (Sergey B Kirpichev)
+* Support inf/nan's in ctx.almosteq(), #802 (Sergey B Kirpichev)
+* Implement mpf.__format__(), see #819, #831, #850, #859, #857, #862, #881,
+  #944 and #966 (Javier Garcia, Sergey B Kirpichev)
+* Support conversion from scalar ndarray's, see #821 (Sergey B Kirpichev)
+* Support rounding modes in mpf.__format__, see #823, #831, #834
+  and #969 (Javier Garcia, Sergey B Kirpichev)
+* Support '%' presentation type for mpf, see #847 (Sergey B Kirpichev)
+* Support gmpy2-like rounding modes in to_str(), see #830 (Javier Garcia)
+* Implement 'a'/'A' formating types for mpf.__format__, see #841 and #870
+  (Sergey B Kirpichev)
+* Add mpc.__format__(), see #855 (Sergey B Kirpichev)
+* Now mpf.__round__() returns mpf, see #826 and #966 (Sergey B Kirpichev)
+* Support 'b' (binary) format type for mpf/mpc, see #867 (Sergey B Kirpichev)
+* Implement mpf.__floordiv__() and mpf.__divmod__(), see #873 (Sergey B
+  Kirpichev)
+* Add parameters for MPContext constructor, see #876 and #963 (Sergey B Kirpichev)
+* Add MPFR-compatible aliases for rounding modes, see #892 (Sergey B
+  Kirpichev)
+* Support negative indexes in matrix, see #897 (Riccardo Orsi)
+* Better introspection support for decorated functions, see #900 (Sergey B
+  Kirpichev)
+* Add moving sofa demo, see #924 (Sergey B Kirpichev)
+* Support spherical Bessel functions (jn/yn), #935 (Sergey B Kirpichev)
+* Add pretty_dps context property to control number of printed digits, see
+  #933 (Sergey B Kirpichev)
+* Support thousands separators for formatting of fractional part, see #925 and
+  #936 (Sergey B Kirpichev)
+* Use PyREPL, as fallback (no IPython), see #941 (Sergey B Kirpichev)
+* Add exp2() and log2(), see #948 (Sergey B Kirpichev)
+* Support rounding property for the mp context, see #963 (Sergey B Kirpichev)
+* Add Fox H-function with rational A/B parameters (foxh()), see #982 (Hongren Zheng)
+* Provide experimental support for free-threading builds, see #993 (Sergey B Kirpichev)
+
+Compatibility:
+
+* Drop Python 2 support, see #629 (Fangchen Li)
+* Drop support for Python versions < 3.9, see #675 and #911 (Sergey B Kirpichev)
+* Drop private mpq class, use Rational's, provided by backend, see #691 and
+  #769 (Sergey B Kirpichev)
+* Drop to_pickable()/from_pickable() helpers, see #667 and #769 (Sergey B
+  Kirpichev)
+* Direct access to _mpf_ tuples now deprecated, please use from/to_man_exp()
+  functions and special constants (finf, fninf and fnan), see
+  #783 (Sergey B Kirpichev)
+* Removed sage backend, see #732 (Sergey B Kirpichev)
+* Drop MPMATH_STRICT environment variable, see #759 (Sergey B Kirpichev)
+* Deprecate current (descending) order of coefficients in polyval(), etc, see
+  #779, #844 and #845 (Sergey B Kirpichev, Warren Weckesser)
+* Deprecate mpmath.math2, see #769 (Sergey B Kirpichev)
+* Importing from the mpmath.libmp submodules is deprecated, use instead ``from
+  mpmath.libmp import foo``, see
+  issue https://github.com/mpmath/mpmath/issues/704#issuecomment-2953536980
+  for available functions (Sergey B Kirpichev)
+* Deprecate bitcount function, see #721 and #955 (Sergey B Kirpichev)
+* Deprecate mpf/mpc_log, see #989 (Sergey B Kirpichev)
+* Deprecate fp.is_special(), see #1042 (Sergey B Kirpichev)
+
+Bug fixes:
+
+* sum_accurately(), betainc() and power() fixes, see #664 (Sergey B Kirpichev)
+* Warn users about Python's true division, see #670 (Sergey B Kirpichev)
+* Propagate nan's in ei_asympt(), see #672 (Sergey B Kirpichev)
+* Fix matrix.__eq__, fix string parsing with underscores, see #679 (Sergey B
+  Kirpichev)
+* Raise IndexError if matrix index out of bounds, see #689 (Sergey B
+  Kirpichev)
+* Fix nan handling in fp.mag() and hyper(), see #688 (Sergey B Kirpichev)
+* Optimize sparse matrix dot product, see #450 (Tyler Chen)
+* Correct pow() for mpf's to be consistent with mpfr/float's, see #690 (Sergey
+  B Kirpichev)
+* Improve hypsum non-convergence behaviour, see #703 (Benjamin Fischer)
+* Fixed TypeError in LU_comp, see #610 (Jan-Philipp Hoffmann)
+* Fix disagreement fp.mod vs mp.mod, see #710 (Sergey B Kirpichev)
+* Skip eigenvectors if left=right=False for one-dimentional matrix, see #713
+  (Sergey B Kirpichev)
+* Fix mpc() constructor to be compatible with complex(), fix disagreement
+  fp.pow vs mp.pow, see #731 (Sergey B Kirpichev)
+* Add derivative keyword argument for besselk(), see #735 (Sergey B Kirpichev)
+* Fix quadosc(), fast case in _hyp2f1(), correct fp.gamma() and fp.isnprint(),
+  see #740 (Sergey B Kirpichev)
+* Pevent erroneous setting of dps/prec on mpmath module, see #678
+  (Colin B. Macdonald)
+* Update splot() for recent matplotlib, see #747 (Sergey B Kirpichev)
+* acos_asin(): don't try to normalize special numbers, fix repr(mp.eps), see
+  #750 (Sergey B Kirpichev)
+* Fix choleksy_solve for complex matrix, see #755 (Qiming Sun)
+* Fix hang in polylog_general(), fix demos, use cholesky_solve() for
+  overdetermined complex linear systems, fix several issues with empty
+  matrices, see #759
+* sqrt(z): special case for infinite z.imag, see #777 (Sergey B Kirpichev)
+* Correct atan2(±inf, ±inf), see #775 (Sergey B Kirpichev)
+* Handle infinite arguments in tan/tanh, see #785 (Sergey B Kirpichev)
+* Drop mpf.__complex__(), workaround 1/z division for acot/asec/acsc/acoth,
+  see #797 (Sergey B Kirpichev)
+* Handle more special cases in besselk and hyp1f1, see #792, #800 and #801
+  (Sergey B Kirpichev)
+* Correct asin/acos for infinite arguments, see #795 (Sergey B Kirpichev)
+* Reduce memory usage for QuadratureRule cache, see #812 (Sergey B Kirpichev)
+* Drop sign from nstr(mpf('inf')) output, see #828 (Sergey B Kirpichev)
+* Improve accuracy of log1p(), see #803 and #854 (Tim Peters, Sergey B
+  Kirpichev)
+* Normalize mpf in mp.npconvert(), fix special cases in bernpoly(), see #839
+  (Sergey B Kirpichev)
+* Fix mpf_div() for prec=0, see #849 (Sergey B Kirpichev)
+* Raise ValueError for complex infininity condition in zeta(s, a), see #864
+  (Sergey B Kirpichev)
+* Enable trap_complex for MDNewton, see #870 (Sergey B Kirpichev)
+* Use correct mixed-mode functions in fsub/fdiv, add special cases for
+  infinities in mpc_*div(), see #873 (Sergey B Kirpichev)
+* Revert "fix ellippi to return an inf instead of raising an exception", see
+  #875 (Sergey B Kirpichev)
+* Reject invalid strings in from_str(), see #886 (Sergey B Kirpichev)
+* Use parity formula for besseli, see #889 (Sergey B Kirpichev)
+* Special case in ctx.hypsum for infinite z, see #902 (Sergey B Kirpichev)
+* Raise an exception if iv's comparison can't be decided, see #903 (Sergey B
+  Kirpichev)
+* Add special case for ±inf in polylog_continuation(), see #904, #1034
+  and #1037 (Sergey B Kirpichev, Colin B. Macdonald)
+* Increase working precision in polylog_general() for negative s, see #898
+  (Sergey B Kirpichev)
+* Correct case for integer n in besselj/besseli, see #909 (Sergey B Kirpichev)
+* Use sum_accurately() in hankel1/2(), see #926 (Sergey B Kirpichev)
+* Ensure mpf_bernoulli() returns normalized answer, see #939 (Sergey B
+  Kirpichev)
+* Use mpf_log1p in acos_asin() helper (implementing Hull et al algorithm), see
+  #948 and #1036 (Sergey B Kirpichev)
+* Fix kwargs passing in the nstr() for mpc, see #964 (David Walker)
+* Fix exception type for int(inf), see #966 (Sergey B Kirpichev)
+* Ensure exp, sin, tan, etc have a correct __name__ attribute, see #997
+  (Warren Weckesser)
+* Matrix raise ValueError in case of negative dimensions, see #1004 (Ayush
+  Baranwal)
+* Support lists in sinm() and cosm(), see #1003 (Ayush Baranwal)
+* Properly handle nan's elliprj(), see #1038 (Sergey B Kirpichev)
+* Raise ValueError for logm(0), see #1017 (Ayush Baranwal)
+* Fix erf(z) with re(z) of large magnitude, see #1039 (Sergey B Kirpichev)
+* Return nan's for polylog(s, nan) or polylog(s, nan+nanj),
+  see #1041 (Sergey B Kirpichev)
+* Fix fp.isnormal() for subnormals, see #1042 (Sergey B Kirpichev)
+
+Maintenance:
+
+* Use codecov/coverage-action, see #674 (Sergey B Kirpichev)
+* Run CI tests with pytest-xdist, see #685 (Sergey B Kirpichev)
+* Add pyproject.toml, depend on flake518, see #684 (Sergey B Kirpichev)
+* Port torture.py/extratest_zeta.py/extratest_gamma.py to the pytest
+  framework, see #687 (Sergey B Kirpichev)
+* Create CITATION.bib, see #681 (Devharsh Trivedi)
+* Avoid using star imports in tests and documentation, see #698 (Sergey B
+  Kirpichev)
+* Fix some py2's remnants and remove old gmpy workarounds, see #699 (Sergey B
+  Kirpichev)
+* Use math.isqrt in isqrt_python calculations, see #695 (Daiki Takahashi)
+* Use gcd() and other bigint's functions from the backend, see #697 (Sergey B
+  Kirpichev)
+* Drop legacy and redundant code, see #701 (Sergey B Kirpichev)
+* Change FPContext to use more functions from the stdlib, see #692 (Sergey B
+  Kirpichev)
+* Avoid dynamic method creation in _mpf, see #702 (Sergey B Kirpichev)
+* Enable testing on CPython 3.12-dev, see #706 (Sergey B Kirpichev)
+* Use bit_length() method instead of bitcount(), see #721 (Sergey B Kirpichev)
+* Use lru_cache() in ifib() and eulernum(), isprime() alternatives from
+  backends, see #722 (Sergey B Kirpichev)
+* Use setuptools_scm to update __version__, see #694 (Sergey B Kirpichev)
+* Run tests on 3.13, see #759 (Sergey B Kirpichev)
+* Do not build depend on pip and wheel, see #758 (Gonzalo Tornaría)
+* Add CONTRIBUTING.rst, see #763 (Sergey B Kirpichev)
+* Simplify ctx_mp_python.py, see #806 (Sergey B Kirpichev)
+* Update gmpy2 deps, see #808 and #813 (Sergey B Kirpichev)
+* Enable testing on 3.14, see #851 (Sergey B Kirpichev)
+* Refactor Github Actions, see #905 (Sergey B Kirpichev)
+* Build and publish wheel, see #913 (David Hotham)
+* Use the intended setuptools_scm integration pattern, see #940 (Ronny
+  Pfannschmidt)
+* Add backport action, see #1042 (Sergey B Kirpichev)
+
+See the release milestone (1.4) for a complete list of issues and pull requests
+involved in this release.
+
+
+--1.3.0--
+Released March 7, 2023
+
+Security issues:
+
+* Fixed ReDOS vulnerability in mpmathify() (CVE-2021-29063) (Vinzent Steinberg)
+
+Features:
+
+* Added quadsubdiv() for numerical integration with adaptive path splitting
+  (Fredrik Johansson)
+* Added the Cohen algorithm for inverse Laplace transforms
+  (Guillermo Navas-Palencia)
+* Some speedup of matrix multiplication (Fredrik Johansson)
+* Optimizations to Carlson elliptic integrals (Paul Masson)
+* Added signal functions (squarew(), trianglew(), sawtoothw(), unit_triangle()
+  sigmoidw()) (Nike Dattani, Deyan Mihaylov, Tina Yu)
+
+Bug fixes:
+
+* Correct mpf initialization from tuple for finf and fninf (Sergey B Kirpichev)
+* Support QR decomposition for matrices of width 0 and 1 (Clemens Hofreither)
+* Fixed some cases where elliprj() gave inaccurate results (Fredrik Johansson)
+* Fixed cases where digamma() hangs for complex input (Fredrik Johansson)
+* Fixed cases of polylog() with integer-valued parameter with complex type
+  (Fredrik Johansson)
+* Fixed fp.nsum() with Euler-Maclaurin algorithm (Fredrik Johansson)
+
+Maintenance:
+
+* Dropped support for Python 3.4 (Sergey B Kirpichev)
+* Documentation cleanup (Sergey B Kirpichev)
+* Removed obsolete files (Sergey B Kirpichev)
+* Added options to runtests.py to skip tests and exit on failure
+  (Jonathan Warner)
+
+
+--1.2.0--
+Released February 1, 2021
+
+Features and optimizations:
+
+* Support @ operator for matrix multiplication (Max Gaukler)
+* Add eta() implementing the Dedekind eta function
+* Optimized the python_trailing function (adhoc-king)
+* Implement unary plus for matrices (Max Gaukler)
+* Improved calculation of gram_index (p15-git-acc)
+
+Compatibility:
+
+* Enable sage backend by default only if SAGE_ROOT is set (Pauli Virtanen)
+* Fix syntax warnings on CPython 3.8 (Sergey B Kirpichev)
+* Changed version requirements to Python 2.7 and 3.4 or later
+  (Sergey B Kirpichev)
+* Improvements to the setup and test code (Sergey B Kirpichev)
+* Fix sys.version comparisons for compatibility with Python 3.10 (Jakub Wilk)
+* Fixes to Python2/3 compatibility for printing (Christian Clauss)
+
+Bug fixes:
+
+* Fix a possible division by zero in shanks() (Pascal Hebbeker)
+* Fixed indexing errors in deHoog, Knight & Stokes inverse laplace
+  transform algorithm (Kris Kuhlman)
+* Corrected branch cuts of the elliprj() function in some cases
+* Fix initialization of iv.matrix from non-interval matrix (Max Gaukler)
+* Preserve function signatures in PrecisionManager (Viet Tran)
+* Implemented float and complex conversions for ivmpf
+  (Jonathan Warner)
+* Fixed issue with scalar-matrix multiplication for interval matrices
+  (Jonathan Warner)
+* Fix estimation of quadrature error with multiple subintervals (Tom Minka)
+* Fixed a problem with the defun decorators (Sergey B Kirpichev)
+* Fix eigenvalue sorting by absolute value (Georg Ostrovski)
+
+Cleanup:
+
+* Documentation corrections (Paul Masson, S.Y. Lee)
+* Remove inaccessible logic in fsum/fdot (Sergey B Kirpichev)
+* Remove broken force_type option for matrix constructor (Max Gaukler)
+* Fix text of the BSD license in LICENSE (Sergey B Kirpichev)
+* Minor code cleanup (Frédéric Chapoton)
+* Removed old, unused code
+
+
+--1.1.0--
+Released December 11, 2018
+
+Bugs:
+* Fixed severe bug in householder() for complex matrices
+  (Michael Kagalenko)
+* Fixed frequently-reported bug where findroot() mysteriously raised
+  UnboundLocalError (Sergey B Kirpichev)
+* Corrected rounding in binary-to-decimal conversion above 500 digits
+* Fixed minor loss of accuracy affecting rf(), ff(), binomial(), beta()
+* Fixed incorrect computation of the Hurwitz zeta function in some cases
+* Fixed accuracy of digamma function near 0
+* Fixed RuntimeError in qfac() in Python 3.7 caused by raising
+  StopIteration (Zbigniew Jędrzejewski-Szmek)
+* Fix to allow NumPy arrays in fdot() (Nico Schlömer)
+
+Features and improvements:
+* Added more automatic conversions from Fraction, Decimal, NumPy types
+  (Jonathan Warner)
+* Support creating mpf from a long literal (ylemkimon)
+* Implemented log1p()
+* Slight speedup of eig()
+* Implement polylog() for general complex s and z by using Hurwitz zeta
+  algorithm as a fallback
+
+Library:
+* Test more CPython and PyPy versions (Sergey B Kirpichev, Aaron Meurer)
+* Drop support for Python 2.6 and 3.2 (Sergey B Kirpichev)
+* Use py.test for test code; lots of code cleanup (Sergey B Kirpichev)
+* Corrections to the documentation (Paul Masson, Connor Behan,
+  Warren Weckesser, Aaron Meurer)
+
+--1.0.0--
+Released September 27, 2017
+
+* Bumped to major version number for 10 year anniversary
+* Added module for inverse Laplace transforms, including the top level
+  function invertlaplace() as well as several different algorithms
+  (Talbot, Gaver-Stehfest and de Hoog) implemented in
+  mpmath.calculus.inverselaplace (Kris Kuhlman)
+* Fixed bugs in elliprg() giving incorrect values for certain input
+* Fixed wrong degree 1 nodes for Gaussian quadrature
+* Made make acot(0) and acoth(0) return a finite result
+* Fixed sieved zeta sum not being used in Python 3, and added cutoff
+  for sieved zeta sum on 32-bit systems when too much memory would be used
+* Fixed zeta(0,0.5) to return correct value instead of raising
+  NoConvergence exception
+* Added detection of exact zeros in gammainc(), in particular fixing
+  NoConvergence error for gammainc(3,-1+1j)
+* Fixed wrong values from besseli() due to improper internal precision
+* Fixed bessely(0,1j) to return complex nan instead of raising NameError
+  (Paul Masson)
+* Changed float() and complex() applied to an mpf or mpc to use rounding
+  to nearest (or the context rounding mode) instead truncating
+* Fix imaginary part of gammainc(n,x), n negative odd int, x < 0
+* Added alternative "phase" color scheme to cplot()
+* Better error message for int(inf) or int(nan) (Aaron Meurer)
+* Fixed polyroots() with error=True
+* Added support to pass optional initial values to polyroots()
+  (Michael Kagalenko)
+* Rewrote the Python major version selection to make it work if something
+  else has redefined xrange (Arne Brys)
+* Switched documentation formula rendering to MathJax (Sergey B Kirpichev)
+* Fixed documentation TeX build (Sergey B Kirpichev)
+* Added PEP8 conformity testing (Sergey B Kirpichev)
+* Various fixes for the test code and test infrastructure on different
+  platforms and Python versions (Sergey B Kirpichev)
+* Fixed module paths in setup.py (Aaron Meurer)
+* Documented more options for methods such as nstr() and hyper()
+* Miscellaneous corrections to the documentation (various)
+
+--0.19--
+Released June 10, 2014
+
+* Moved issue tracking to github and the main website to mpmath.org.
+  Several URLs and issue numbers were updated in the documentation
+  (Sergey B Kirpichev)
+* Enabled automatic testing with Travis CI (Sergey B Kirpichev)
+* Fixed many doctest issues (Sergey B Kirpichev)
+* Converted line endings to LF (Ondrej Certik)
+* Made polyroots() more robust (Ondrej Certik)
+
+--0.18--
+Released December 31, 2013
+
+Linear algebra:
+* added qr() for matrix QR factorization (contributed by Ken Allen)
+* added functions eigsy(), eighe(), eig() to compute matrix
+  eigenvalues (contributed by Timo Hartmann)
+* added functions svd(), svd_r(), svd_c() for singular value
+  decomposition of matrices (contributed by Timo Hartmann)
+* added calculation of Gaussian quadrature rules for various weight
+  functions (contributed by Timo Hartmann)
+* improved precision selection in exp_pade() (contributed by
+  Mario Pernici)
+
+Special functions:
+* fixed ellippi() to return an inf instead of raising an exception
+* fixed a crash in zeta() with huge arguments
+* added functions for computing Stirling numbers
+  (stirling1(), stirling2())
+* improved the computation of zeros of zeta at high precision
+  (contributed by Juan Arias de Reyna)
+* fixed zeta(-x) raising an exception for tiny x
+* recognize when lerchphi() can call zeta() or polylog(),
+  handling those cases faster
+
+Compatibility:
+* fixed gmpy2 compatibility issues (contributed by Case Van Horsen)
+* better solutions for python 2/3 compatibility,
+  using Benjamin Peterson's six.py
+* fixes to allow mpmath to run in non-sage mode when sage is available
+* support abstract base classes (contributed by Stefan Krastanov)
+* use new-style classes to improve pypy performance
+
+Other:
+* added Levin, Sidi-S and Cohen/Villegas/Zagier series
+  transformations (contributed by Timo Hartmann)
+* added isfinite() utility function
+* fixed a problem with bisection root-finding
+* fixed several documentation errors
+* corrected number of coefficients returned by diffs() with
+  method='quad'
+* fixed repr(constant) being slow at high precision
+* made intervals hashable
+
+--0.17--
+Released February 1, 2011
+
+Compatibility:
+
+* Python 3 is now supported
+* Dropped Python 2.4 compatibility
+* Fixed Python 2.5 compatibility in matrix slicing code
+* Implemented Python 3.2-compatible hashing, making mpmath numbers
+  hash compatible with extremely large integers and with fractions
+  in Python versions >= 3.2 (contributed by Case Vanhorsen)
+
+Special functions:
+
+* Implemented the von Mangoldt function (mangoldt())
+* Implemented the "secondary zeta function" (secondzeta()) (contributed
+  by Juan Arias de Reyna).
+* Implemented zeta zero counting (nzeros()) and the Backlund S function
+  (backlunds()) (contributed by Juan Arias de Reyna)
+* Implemented derivatives of order 1-4 for siegelz() and siegeltheta()
+  (contributed by Juan Arias de Reyna)
+* Improved Euler-Maclaurin summation for zeta() to give more accurate
+  results in the right half-plane when the reflection formula
+  cannot be used
+* Implemented the Lerch transcendent (lerchphi())
+* Fixed polygamma function to return a complex NaN at complex
+  infinity or NaN, instead of raising an unrelated exception.
+
+
+--0.16--
+Released September 24, 2010
+
+Backends and distribution:
+
+* Added Sage hooks for Cython versions of exp, ln, cos, sin,
+  hypergeometric series, and some related functions
+* Fixed imports for gmpy2 compatibility (contributed by Case Van Horsen)
+* Removed documentation from main mpmath package to save space (a separate
+  tar.gz file is now provided for the documentation sources)
+* Fixed matplotlib version detection
+* Converted files to Unix line endings
+
+Special functions:
+
+* Started adding plots of special functions to the documentation
+* Added Anger and Weber functions (angerj(), webere())
+* Added Lommel functions (lommels1(), lommels2())
+* Added interval versions of gamma(), loggamma(), rgamma() and
+  factorial()
+* Rewritten Airy functions to improve speed and accuracy
+* Support for arbitrary-order derivatives of airyai(), airybi()
+* Added Airy function zeros (airyaizero(), airybizero())
+* Added Scorer functions (scorergi(), scorerhi())
+* Added computation of Bessel function zeros and Bessel function
+  derivative zeros (besseljzero(), besselyzero())
+* Fixed besselj(mpc(n), z)
+* Rewritten lambertw() to fix various subtle bugs and robustly handle
+  numerical difficulties near branch cuts and branch points.
+* Fixed fp.lambertw() to behave the same on branch cuts on systems with
+  and without signed-zero floats
+* Added Carlson symmetric incomplete elliptic integrals
+  (elliprf(), elliprc(), elliprj(), elliprd(), elliprg())
+* Added Legendre incomplete elliptic integrals (ellipf(), ellippi(),
+  ellipe() with two arguments)
+* Implemented Parabolic cylinder functions (pcfd(), pcfu(), pcfv(),
+  pcfw())
+* Implemented Euler-Maclaurin summation for hypergeometric functions
+  of order (p,p-1) to support evaluation with z close to 1 in remaining cases
+* Fixed a bug in hypergeometric series summation, causing occasional
+  inaccurate results and incorrect detection of zeros
+* Fixed qfrom(m=...)
+
+Calculus:
+
+* Implemented generators diffs_exp(), diffs_prod() for composing
+  derivatives
+* Implemented Abel-Plana summation for infinite series (sumap())
+
+Basic arithmetic and functions:
+
+* Implemented matrix slice indexing, supporting submatrix
+  extraction and assignment (contributed by Ioannis Tziakos)
+* Added missing constant fp.glaisher
+* Fixed a bug preventing internal rational numbers from being
+  hashable
+* Fixed bug in isnpint()
+* Fixed a bug in cos_sin() for pure imaginary argument
+* Slightly improved performance for elementary functions of pure
+  real or pure imaginary mpc inputs
+* Fixed plot() with real-valued mpc instances
+* Fixed cplot() to work with endpoints of other type than float/int
+
+
+--0.15--
+Released June 6, 2010
+
+Basic transcendental functions:
+
+* Reimplemented all elementary functions except log, reducing
+  overhead and giving asymptotic speedups at high precision
+* Reimplemented gamma() and loggamma(), improving speed and
+  fixing accuracy in corner cases
+* Added rgamma() (reciprocal gamma function)
+* Added a stress test suite for the gamma function
+* Provided top-level functions cos_sin() and cospi_sinpi() for fast
+  simultaneous computation
+
+Riemann zeta function:
+
+* New zetazeros() implementation, supporting arbitrarily large indices
+  (contributed by Juan Arias de Reyna)
+* Tuned algorithm selection in zeta() for complex arguments
+  (contributed by Juan Arias de Reyna)
+* Accelerated computation of zeta function series using sieving
+
+Special functions:
+
+* Added qfrom(), qbarfrom(), mfrom(), kfrom(), taufrom() for elliptic
+  argument conversion
+* Merged jsn(), jcn(), jdn() -> ellipfun() and generalized it to compute
+  all 12 Jacobi elliptic functions
+* Implemented the Klein j-invariant (kleinj())
+* Implemented the q-Pochhammer symbol (qp())
+* Implemented q-factorial (qfac()) and q--gamma (qgamma())
+* Implemented q-hypergeometric series (qhyper())
+* Implemented bilateral hypergeometric series (bihyper())
+* Implemented Appell 2D hypergeometric series F2-F4 (appellf2()-appellf4())
+* Implemented generalized 2D hypergeometric series (hyper2d())
+* Fixed gammainc() for integer-valued complex argument (contributed by
+  Juan Arias de Reyna)
+* Fixed asymptotic expansion of hyp1f1() (contributed by Juan Arias de Reyna)
+
+Numerical calculus:
+
+* Added support for multidimensional series in nsum()
+* Made nprod() faster by default by extrapolating directly instead of
+  calling nsum()
+* Changed some options for diff()/diffs()
+* Made taylor() chop tiny coefficients by default
+* Added support for partial derivatives in diff()
+
+Interval arithmetic:
+
+* All interval arithmetic functionality moved to a separate context
+  namespace (iv)
+* Preliminary support for complex intervals (iv.mpc)
+* Fixed interval cos/sin to support intervals overlapping zeros/extreme points
+* Implemented interval atan2
+* Implemented exp/log/cos/sin for complex intervals
+* Some other interface changes to interval code
+
+Utility functions:
+
+* Made chop() use relative rather than absolute tolerance for
+  real/imaginary parts
+* Optimized floor(), ceil(), isinf(), isnan(), isint()
+* Implemented nint(), frac(), isnormal()
+* Fixed and documented semantics for isinf(), isin(), isnan()
+* Added utility functions autoprec(), maxcalls(), memoize()
+
+Miscellaneous tweaks and fixes:
+
+* Support complex conjugation in fdot()
+* Added support for Cholesky decomposition of complex matrices
+* Fixed a small precision bug in linear algebra functions
+* Suppress NoConvergence exception when plotting
+* Removed some dirty code to improve PyPy compatibility
+* Fixed plotting to work with mpmath numbers in the interval specification
+* Fixed fp arithmetic on systems where math.log and math.sqrt return NaN
+  instead of raising an exception
+* Fixed fp.conj for Python 2.4 and 2.5
+* Fixed quadrature to work with reversed infinite intervals such as [0,-inf]
+* Renamed modf() -> fmod() for consistency
+
+--0.14--
+Released February 5, 2010
+
+General changes:
+
+* Fully separated the code into "low-level" and "high-level", permitting the
+  use of alternative contexts (the mpmath.mp object provides the default
+  implementation)
+* Implemented a context for fast double-precision arithmetic using Python
+  types (mpmath.fp) 
+* Implemented hooks for importing a faster version of mp arithmetic from Sage
+* Implemented optimized fp versions of certain functions (including erf, erfc,
+  gamma, digamma, ei, e1)
+* Renamed and reorganized various internal modules and methods (including
+  merging low-level modules into mpmath.libmp). This should not affect most
+  external code using top-level imports.
+
+Plotting:
+
+* Implemented splot() for 3D surface plots (contributed by Jorn Baayen)
+* Permit calling plot functions with custom axes (contributed by Jorn Baayen)
+
+Matrices:
+
+* Fixed lu_solve for overdetermined systems (contributed by Vinzent Steinberg)
+* Added conjugate matrix transpose (contributed by Vinzent Steinberg)
+* Implemented matrix functions (expm, cosm, sinm, sqrtm, logm, powm)
+
+Miscellaneous:
+
+* Prettier printing of numbers with leading zeros at small precisions
+* Made nstr pass on kwargs, permitting more formatting options
+* Fixed wrong directed rounding of addition of numbers with large magnitude
+  differences
+* Fixed several docstring typos (contributed by Chris Smith)
+* Fixed a bug that prevented caching of quadrature nodes to work optimally.
+
+Special functions:
+
+* Implemented fast evaluation for large imaginary heights of the Riemann zeta
+  function, Z function and derived functions using the Riemann-Siegel
+  (contributed by Juan Arias de Reyna)
+* Unified the zeta() and hurwitz() functions, automatically selecting a fast
+  algorithm
+* Improved altzeta() to fall back to zeta() for large arguments
+* Fixed accuracy of zeta(s) for s ~= 1
+* Implemented exact evaluation of Euler numbers (contributed by Juan Arias
+  de Reyna)
+* Implemented numerical evaluation of Euler numbers and Euler polynomials
+  (eulernum(), eulerpoly())
+* Fixed bernpoly() and eulerpoly() to compute accurate values for large
+  parameters
+* Fixed accuracy problems for hypergeometric functions with large parameters
+* Faster evaluation of hypergeometric series using on-the-fly code generation
+* Optimized hypercomb to detect certain zero terms symbolically
+* Removed the djtheta function (jtheta() accepts a derivative parameter)
+* Implemented li(x, offset=True) to compute the offset logarithmic integral
+* Fixed wrong branch in Lambert W function for certain complex inputs
+* Implemented the reflection formula for the Barnes G-function,
+  superfactorials, hyperfactorials, permitting large arguments in the left
+  half-plane
+* Implemented analytic continuation to |z| >= 1 for hypergeometric functions
+  pFq with p=q+1; added hyp3f2()
+* Implemented Borel summation of divergent pFq functions with p > q+1
+* Implemented automatic degree reduction of hypergeometric functions with
+  repeated parameters
+* Added convenience functions expj(), expjpi()
+* Use Mathematica's convention for the continuation of the Meijer G-function
+* Added phase(), polar(), rect() functions for compatibility with the
+  Python 2.6 cmath module
+* Implemented spherical harmonics (spherharm())
+* Optimized ci(), si(), chi(), shi() for complex arguments by evaluating
+  them in terms of ei()
+* Optimized hyp2f1 for z ~= -1
+
+--0.13--
+Released August 13, 2009
+
+New special functions:
+
+* The generalized exponential integral E_n (expint(), e1() for E_1)
+* The generalized incomplete beta function (betainc())
+* Whittaker functions (whitm(), whitw())
+* Struve functions (struveh(), struvel())
+* Kelvin functions (ber(), bei(), ker(), kei())
+* Cyclotomic polynomials (cyclotomic())
+* The Meijer G-function (meijerg())
+* Clausen functions (clsin(), clcos())
+* The Appell F1 hypergeometric function of two variables (appellf1())
+* The Hurwitz zeta function, with nth order derivatives (hurwitz())
+* Dirichlet L-series (dirichlet())
+* Coulomb wave functions (coulombf(), coulombg(), coulombc())
+* Associated Legendre functions of 1st and 2nd kind (legenp(), legenq())
+* Hermite polynomials (hermite())
+* Gegenbauer polynomials (gegenbauer())
+* Associated Laguerre polynomials (laguerre())
+* Hypergeometric functions hyp1f2(), hyp2f2(), hyp2f3(), hyp2f0(), hyperu()
+
+Evaluation of hypergeometric functions:
+
+* Added the function hypercomb() for evaluating expressions containing
+  hypergeometric series, with automatic handling of limits
+* The available hypergeometric series (of orders up to and including 2F3)
+  implement asymptotic expansions with respect to the last argument z, allowing
+  fast and accurate evaluation anywhere in the complex plane. A massive number
+  of functions, including Bessel functions, error functions, etc., have been
+  updated to take advantage of this to support fast and accurate evaluation
+  anywhere in the complex plane.
+* Fixed hyp2f1 to handle z close to and on the unit circle (supporting
+  evaluation anywhere in the complex plane)
+* hyper() handles the 0F0 and 1F0 cases exactly
+* hyper() eventually raises NoConvergence instead of getting stuck in
+  an infinite loop if given a divergent or extremely slowly convergent series
+
+Other improvements and bug fixes to special functions:
+
+* gammainc is much faster for large arguments and avoids catastrophic
+  cancellation
+* Implemented specialized code for ei(x), e1(x), expint(n,x) and gammainc(n,x)
+  for small integers n, making evaluation much faster
+* Extended the domain of polylog
+* Fixed accuracy for asin(x) near x = 1
+* Fast evaluation of Bernoulli polynomials for large z
+* Fixed Jacobi polynomials to handle some poles
+* Some Bessel functions support computing nth order derivatives
+* A set of "torture tests" for special functions is available as
+  tests/torture.py
+
+Other:
+* Implemented the differint() function for fractional differentiaton / iterated
+  integration
+* Added functions fadd, fsub, fneg, fmul, fdiv for high-level arithmetic with
+  controllable precision and rounding
+* Added the function mag() for quick order-of-magnitude estimates of numbers
+* Implemented powm1() for accurate calculation of x^y-1
+* Improved speed and accuracy for raising a pure imaginary number to
+  an integer power
+* nthroot() renamed to root(); root() optionally computes any of
+  the non-principal roots of a number
+* Implemented unitroots() for generating all (primitive) roots of unity
+* Added the mp.pretty option for nicer repr output
+
+--0.12--
+Released June 9, 2009
+
+General
+* It is now possible to create multiple context objects and use context-local
+  methods instead of global state/functions (e.g. mp2=mp.clone(); mp2.dps=50;
+  mp2.cos(3)). Not all functions have been converted to context methods, and
+  there are some bugs, so this feature is currently experimental.
+* If mpmath is installed in Sage 4.0 or later, mpmath will now use sage.Integer
+  instead of Python long internally.
+* Removed instances of old-style integer division from the codebase.
+* runtests.py can be run with -coverage to generate coverage statistics.
+
+Types and basic arithmetic
+
+* Fixed comparison with -inf.
+* Changed repr format of the mpi interval type to make eval(repr(x)) == x.
+* Improved printing of intervals, with configurable output format (contributed
+  by Vinzent Steinberg based on code by Don Peterson).
+* Intervals supported by mpmathify() and nstr() (contributed by Vinzent
+  Steinberg).
+* mpc is now hashable.
+* Added more formatting options to the internal function to_str.
+* Faster pure-Python square root.
+* Fix trailing whitespace giving wrong values in str->mpf conversion.
+
+Calculus
+
+* Fixed nsum() with Euler-Maclaurin summation which would previously
+  ignore the starting index and sum from n=1.
+* Implemented Newton's method for findroot() (contributed  by Vinzent
+  Steinberg).
+
+Linear algebra
+
+* Fixed LU_decomp() to recognize singular matrices (contributed by Jorn Baayen).
+* The various norm functions were replaced by the generic vector norm
+  function norm(x,p) and the generic matrix norm function mnorm(x,p).
+
+Special functions:
+
+* Some internal caches were changed to always slightly overallocate
+  precision. This fixes worst-case behavior where previously the cached
+  value had to be recomputed on every function call.
+* Fixed log(tiny number) returning nonsense at high precision.
+* Fixed gamma() and derivative functions such as binomial() returning
+  wrong results at integer inputs being divisible by a large power of 2.
+* Fixed asin() not to raise an exception at high precision (contributed
+  by Vinzent Steinberg).
+* Optimized the AGM code for the natural logarithm, making the previously
+  used Newton method at intermediate precisions obsolete.
+* The arithmetic-geometric mean function agm() is now an order of magnitude
+  faster at low precision.
+* Faster implementations of ellipk() and ellipe().
+* Analytic continuation of ellipe() to |x| >= 1 implemented.
+* Implemented the log gamma function (loggamma()) with correct branch
+  cuts (slow, placeholder implementation).
+* Fixed branch cuts of hyperfac().
+* Implemented the Riemann-Siegel Z-function (siegelz()).
+* Implemented the Riemann-Siegel theta function (siegeltheta()).
+* Implemented calculation of Gram points (grampoint()).
+* Implemented calculation of Riemann zeta function zeros (zetazero()).
+* Implemented the prime counting function: a slow, exact version (primepi()).
+  and a fast approximate version (primepi2()) that gives a bounding interval.
+* Implemented the Riemann R prime counting function (riemannr()).
+* Implemented Bell numbers and polynomials (bell()).
+* Implemented the expm1() function.
+* Implemented the 'polyexponential function' (polyexp()).
+* Implemented the twin prime constant (twinprime) and Mertens' constant
+  (mertens).
+* Implemented the prime zeta function (primezeta()).
+
+
+--0.11--
+Released January 26, 2009
+
+General:
+
+* Most of the documentation is now generated from docstrings
+  using Sphinx' autodoc feature, and proper LaTeX is used
+  for mathematical formulas. A large amount of new documentation
+  has been written.
+* Improved gmpy backend. Using gmpy-1.04 gives a ~30% unit tests
+  speedup over 1.03, with speedups in the range of 2-3x for
+  specific operations (contributed by Case van Horsen and
+  Mario Pernici).
+* Mpmath imports slightly faster due to not trying to
+  load the 'random' library
+
+Numerical calculus, etc:
+
+* Implemented a fast high-precision ODE solver (to replace the slow
+  and low-accuracy RK4 algorithm) (odefun())
+* Created an intelligent function nsum() to replace sumrich/sumsh
+* Implemented nprod() for computing infinite products
+* Rewrote limit() to use the same adaptive extrapolation algorithm
+  as nsum()
+* Multidimensional nonlinear solving with Newton's method
+  implemented in findroot() (contributed by Vinzent Steinberg)
+* Simplified the implementation and interface of sumem()
+* Reimplemented Shanks transformation for nsum using Wynn's epsilon
+  algorithm (shanks())
+* Reimplemented Richardson extrapolation slightly more simply and
+  efficiently (richardson())
+* Prevent shanks() from exiting prematurely by adding
+  random noise to zeros
+* Removed the obsolete secant() function (see findroot())
+* Implemented high-order derivatives (diff(), diffs())
+* Implemented calculation of Taylor series (taylor())
+* Implemented calculation of Fourier series (fourier(), fourierval())
+* Implemented Pade approximation (pade()) (contributed by
+  Mario Pernici)
+* Better cancel condition for findroot() (contributed by
+  Vinzent Steinberg)
+* Some refactoring of numerical integration code
+* Fix erroneous nodes for 0-th order Gauss-Legendre quadrature,
+  which was causing unnecessary slowness
+* Quadrature nodes are cached for arbitrary intervals, giving a
+  30% speedup for repeated integrations
+* Unified interface and added more options for identify(), pslq(), findpoly()
+
+New special functions:
+
+* Implemented polylogarithms (polylog())
+* Implemented Bernoulli polynomials (bernpoly())
+* Implemented the Barnes G-function (barnesg())
+* Implemented double factorials (fac2())
+* Implemented superfactorials (superfac())
+* Implemented hyperfactorials (hyperfac())
+* Replaced lower_gamma and upper_gamma with a more versatile
+  function gammainc() for computing the generalized (and optionally
+  regularized) incomplete gamma function
+* Implemented sinc() and sincpi()
+* Implemented Fibonacci numbers (fib())
+* Implemented the Dirichlet eta function (altzeta())
+* Implemented the inverse error function (erfinv())
+* Jacobi theta functions and elliptic functions were essentially
+  rewritten from scratch, making them much faster and more
+  general. Renamed Jacobi theta functions: jacobi_theta -> jtheta,
+  etc. (contributed by Mario Pernici)
+* Implemented derivatives of jtheta (djtheta) (contributed by
+  Mario Pernici)
+* Implemented Bessel Y, I, K functions (bessely, besseli,
+  besselk; Bessel J functions were also renamed to besselj)
+  also renamed)
+* Generalized Stieltjes constants can now be computed,
+  with stieltjes(n,a)
+* Implemented Hankel functions (hankel1, hankel2)
+
+Speed improvements and bugfixes to special functions:
+* Fast logarithm at very high precision using the formula by
+  Sasaki and Kanada (contributed by Mario Pernici)
+* Slightly faster logarithm at low precision (contributed by
+  Mario Pernici)
+* Faster exponential function at high precision, using
+  Newton's method (contributed by Mario Pernici)
+* Faster computation of ln2 and ln10 by means of binary splitting
+  (contributed by Mario Pernici)
+* Fixed accuracy problems in sinpi() and cospi()
+* Correct evaluation of beta() at limits
+* Much faster evaluation of stieltjes(n), using an improved integral
+  formula
+* Fixed bernoulli() being inaccurate for large n and low precision,
+  and being needlessly slow for small n and huge precision
+* Fixed accuracy of zeta(s) for large negative re(s)
+* Fixed accuracy problems for asinh, atanh and tanh
+* Fixed accuracy of airyai() for large x.real
+* Fixed bug in nthroot() for very large arguments (contributed by
+  Mario Pernici)
+* Fixed accuracy of log(x) for complex |x| ~= 1
+* Fixed accuracy of exp(n), n a huge integer and prec >= 600
+* Slightly faster hypergeometric functions with rational parameters
+  (contributed by Mario Pernici)
+* Faster and more accurate calculation of ci(x), si(x)
+* Faster and more accurate calculation of ei(x) for large x,
+  using an asymptotic expansion (contributed by Mario Pernici)
+* Fixed accuracy bugs in theta functions (contributed by
+  Mario Pernici)
+* The Lambert W function returns more appropriate values at infinities
+
+Arithmetic and basic interface:
+* Square roots are now rounded correctly
+* Made float(huge) -> inf and float(1/huge) -> 0 instead of
+  raising OverflowError
+* Renamed convert_lossless -> mpmathify
+* mpmathify() accepts strings representing fractions or complex
+  numbers (contributed by Vinzent Steinberg)
+* Fixed a bug in interval multiplication giving wrong signs
+* Added monitor() to monitor function evaluation
+* Implemented a chop() utility function for deletion of numerical noise
+* Added re(), im(), conj(), fabs(), mpf.conjugate()
+* Fixed the != operator for intervals
+* Added functions fsum, fprod, fdot for efficient computation of
+  sums, products and dot products of lists of mpf:s or mpc:s
+
+Matrices:
+
+* Generation of Hilbert matrices (hilbert()) (contributed by
+  Vinzent Steinberg)
+* Added lu_solve_mat() to solve a*x=b where a and b are matrices (contributed
+  by Mario Pernici)
+* Implemented computation of matrix exponentials (exp_pade()) (contributed
+  by Mario Pernici)
+* Prettier repr of complex matrices (contributed by Vinzent Steinberg)
+* Speedups by using fdot and fsum (contributed by Vinzent Steinberg)
+
+--0.10--
+Released October 15, 2008
+
+Interface / general:
+* Mpmath now works with Python 2.6
+* Implemented function plotting via 'plot' and 'cplot' (requires
+  matplotlib)
+* Removed global rounding mode (always rounding to nearest by default)
+* Instead added 'prec', 'dps', 'rounding' keyword arguments to
+  standard functions, for optional fine-grained control over precision
+  and rounding
+* Implemented isinf, isnan, isint, utility functions
+* A large number of internal functions were moved and/or renamed to
+  improve consistency. This particularly affects low-level mpf
+  functions (lib.fadd -> libmpf.mpf_add, etc).
+* Syntax for some operations was changed (see details below)
+* The test runner (runtests.py) was updated to support running
+  isolated tests and to allow a local import of mpmath
+* Unit tests can now be run with import mpmath; mpmath.runtests()
+* Implicit imports are no longer used internally in the main codebase.
+  (This will hopefully make the source easier to read, and can catch
+  installation problems more cleanly.)
+
+Added linear algebra functions (contributed by Vinzent Steinberg):
+* Provided a matrix class
+* Computation of powers, inverses, determinants
+* Linear system solving using LU, QR and Cholesky
+* Vector and matrix norms
+* Calculation of condition numbers
+
+Improvements to interval arithmetic:
+* Fixed rounding direction for negative numbers and related
+  spurious bugs
+* Fix interval exponentiation (all cases should work now)
+* Basic interval arithmetic is up to 10x faster
+* sqrt, exp, log, sin, cos and a few other functions
+  accept interval arguments
+* Intervals supported in matrices
+
+Changes to root-finding code:
+* secant renamed to findroot
+* findroot was made more general; many useful alternative root-finding
+  algorithms were implemented (contributed by Vinzent Steinberg)
+
+Improvements to special functions:
+* Implemented polygamma functions
+* Implemented harmonic numbers
+* Implemented Stieltjes constants
+* Made gamma more accurate for huge arguments and/or precision
+* Made zeta more accurate in various cases
+* Made zeta typically 2-5x faster
+* Much more efficient computation of zeta for huge s (zeta(s) ~= 1)
+* Optimized numerical calculation of Bernoulli numbers
+* Fast exact calculation of huge Bernoulli numbers via zeta and the
+  von Staudt-Clausen theorem
+* Using AGM to compute ellipk, which is much faster and works
+  in the entire complex plane
+* Allow single-argument form agm(x) = agm(1,x)
+* Faster and more accurate computation of erf
+* Added fast and accurate implementation of erfc
+* Normal probability functions npdf, ncdf
+* Fixed directed rounding in corner cases for various functions
+
+Improvements to numerical integration:
+* Changed syntax for integration (quad(f, [a, b], options))
+* Implemented Gauss-Legendre quadrature
+* Direct support for triple integrals (quad(f, X, Y, Z))
+* Interval can be a list of several points, to split integration
+  into subintervals
+* Oscillatory quadrature uses Gauss-Legendre instead of tanh-sinh,
+  since this is typically faster
+* Fixed minor rounding bug in tanh-sinh quadrature not giving
+  complete symmetry in the nodes
+* Implemented quadrature rules in classes for improved extensibility
+
+Various speed improvements:
+* Up to 3x faster computation of log(x) at low precision, due to using
+  Taylor series with argument reduction and partial caching
+* About 2x faster log(x) at very high precision due to more efficient
+  computation of exp in the Newton iteration
+* Up to 10x faster computation of atan(x) at low to medium precision,
+  due to using Taylor series with argument reduction and partial caching
+* Faster pickling due to using hex() instead of long()
+* Optimized code for Khinchin's constant (2.5x faster at 1000 digits)
+* Optimized code for Glaisher's constant (1.5x faster at 1000 digits)
+* Faster algorithm for Euler's constant (10x faster at 10000 digits)
+* Rewrote PSLQ to use fixed-point arithmetic, giving a ~7x speedup
+  in pslq, findpoly and identify
+
+Miscellaneous bugfixes:
+* Fixed nthroot for n = -1, 0, 1
+* Fixed inf/2**n and nan/2**n returning zero
+
+--0.9--
+Released August 23, 2008
+
+* gmpy mpzs are used instead of python ints when available, for
+  huge speedups at high precision (contributed by Case Van Horsen)
+* using binary splitting to compute pi and e near-optimally
+* mpmath includes __version__ information
+* arange behaves more like range (contributed by Vinzent Steinberg)
+* asymptotically faster trigonometric functions via Brent's trick
+  (contributed by Mario Pernici)
+* asymptotically faster inverse trigonometric functions via Newton's
+  method (contributed by Mario Pernici)
+* added Jacobi elliptic functions 1-4, sn, cn, dn (contributed by Mike
+  Taschuk)
+* polyval, polyroots and related functions now use the same order
+  for coefficients as scipy and matlab (i.e. the reverse order of what
+  was used previously in mpmath)
+* fixed polyroots for degree-0 polynomials (contributed by Nimish Telang)
+* added convenience functions (log10, degrees, radians, frexp, modf, ln,
+  arg, sign)
+* added fast cbrt and nthroot functions for computing nth roots
+  (contributed by (Mario Pernici)
+* added various exponential integrals (ei, li, si, ci, shi, chi, erfi)
+* added airy functions (airyai, airybi)
+* more __op__ and __rop__ methods return NotImplemented where
+  appropriate
+* external classes can define a special method _mpmath_ to interact
+  with mpmath numbers and functions
+* fixed some corner cases in atan2
+* faster rand()
+
+--0.8--
+Released April 20, 2008
+
+New features:
+* the full set of reciprocal trigonometric and hyperbolic functions
+  and their inverses (cotangent, secant, etc) is available
+* oscillatory quadrature algorithm
+* the PSLQ algorithm and constant recognition functions
+* Richardson and Shanks transformations for computing limits and series
+* Euler-Maclaurin summation of series
+* basic ODE solvers (contributed by Ondrej Certik)
+* the Lambert W function
+* arithmetic-geometric mean function
+* generic hypergeometric series and some special hypergeometric
+  functions (elliptic integrals, orthogonal polynomials)
+* several more mathematical constants
+* fast sequential computation of integer logarithms and Bernoulli
+  numbers
+* Bessel function jv works for complex arguments and noninteger v
+* support for trapping complex results
+* using Sphinx to generate HTML documentation
+
+Bugfixes, speed enhancements, and other improvements:
+* compatibility tests should now pass on systems where Python is
+  compiled to use 80-bit registers for floating-point operations
+* fixed mpmath to work with some versions of Python 2.4 where a
+  list indexing bug is present in the Python core
+* better algorithms for various complex elementary functions
+  (tan and tanh by Fredrik; sqrt, acos, asin, acosh and asinh
+  improved by Mario Pernici)
+* multiplication and integer powers for complex numbers is faster
+  and more accurate
+* miscellaneous speed improvements to complex arithmetic (contributed
+  by Mario Pernici)
+* faster computation of cos and sin when only one of them is needed
+  (contributed by Mario Pernici)
+* slightly faster square roots at low precision (contributed by
+  Mario Pernici)
+* fixed computation of exp(n) for negative integers and x**y for
+  negative half integers y
+* mpf ** complex now works
+* faster generation of quadrature nodes (contributed by Mario Pernici)
+* faster change of variables for quadrature
+* comparisons and conversions have been optimized slightly.
+  comparisons with float(nan) also work as intended.
+* str() is several times faster at very high precision
+* implementations of most elementary functions moved to the lib
+  and libmpc modules for cleaner separation of functionality
+* the rounding argument for lib and libmpc functions, and for
+  some functions also the the prec argument, are now optional,
+  resulting in cleaner and slightly faster lib code
+* gamma and factorial are about 2x faster
+* polyroots returns nicer results
+* pickling now works for mpf and mpc instances
+
+--0.7--
+Released March 12, 2008
+
+* the interface for switching precision and rounding modes has been
+  changed. instead of changing mpf.prec, there is a new object mp
+  which holds the precision as mp.prec. this change improves
+  flexibility in the implementation. it will unfortunately break
+  any existing code written for mpmath, but the broken code should
+  be trivial to update.
+* the functions workprec, workdps, extraprec, extradps have been
+  introduced for switching precision in a more safe manner,
+  ensuring that the precision gets reset when finished. they can
+  be used with the 'with' statement available in python 2.5
+* improved documentation (manual.html)
+* the round-half-down and round-half-up modes have been deprecated,
+  since they added complexity without being particularly useful.
+  round-half-even has been renamed to round-nearest.
+* implemented the functions nstr, nprint for printing numbers with
+  a small or custom number of digits
+* accuracy of cos and sin near roots has been fixed. computing
+  sin(x) or cos(x) where x is huge is also much faster
+* implemented a magical constant eps that gives the "machine"
+  epsilon
+* additional mathematical functions: implemented Catalan's constant
+  and Bessel functions J_n(x) for integer n and real x
+* new functions diff and diffc for numerical differentiation
+* implemented the ldexp function for fast multiplication by 2**n
+* mpf uses rich comparison methods (contributed by Pearu Peterson)
+* epydoc-friendly docstrings (contributed by Pearu Peterson)
+* support creating mpf from float nan or inf
+* fixed printing of complex numbers with negative imaginary part
+* flattened package structure to simplify inclusion of mpmath in other
+  packages
+* external classes can interoperate with mpf and mpc instances
+  by defining _mpf_ or _mpc_ properties
+* renamed lib.fpow -> lib.fpowi and implemented lib.fpow for general
+  real powers. <mpf> ** <mpf> should now be slightly faster and more
+  robust
+* the internal number representation has been changed to include
+  an explicit sign bit. as a result of this change and other small
+  tweaks, arithmetic is up to 20% faster and the total running
+  time for mpmath's unit tests has dropped 10%.
+* miscellaneous speed improvements:
+  * <mpf> ** <int> is 2-3 times faster (contributed by Mario Pernici)
+  * <mpf> * <int> and <int> * <mpf> is roughly twice as fast
+  * <int> / <mpf> is roughly twice as fast (contributed by Mario
+    Pernici)
+  * exp and log are about 10% faster
+  * fast computation of e and exp(n) when precision is extremely high
+
+--0.6--
+Released January 13, 2008
+
+* added the mpi type for interval arithmetic
+* powers with integer exponents are computed with directed rounding
+  all the way through to preserve interval bounds more robustly
+  (however, the code is not fully tested and may have some bugs)
+* string input to mpf.__new__() can now be unicode
+* mpf.__eq__ now works in pypy
+* infs and nans are now implemented in mpmath.lib, resulting in
+  considerable simplification of the mpf class implementation
+* partial support for infs and nans in functions, e.g.
+  exp(inf) -> inf and exp(-inf) -> 0 now work.
+* renamed several files. created mpmath.apps and moved tests into
+  the main mpmath directory
+* wrote script to permit running unit tests without py.test available
+* improved bit counting code in fadd, fmul and fdiv, plus other
+  small performance tweaks, resulting in a 20-30% speedup for
+  arithmetic
+
+--0.5--
+Released November 24, 2007
+
+* added the quad module for arbitrary-precision numerical integration
+* floor and ceil functions available
+* implemented __mod__ and __rmod__ for the mpf class
+* partial support for the special numbers +inf, -inf and nan
+* faster multiplication and division (up to 40% faster with psyco)
+* simplified syntax for conversion function (from_int instead of
+  from_int_exact, etc)
+* renamed cgamma to euler
+* more documentation strings
+
+--0.4--
+Released November 3, 2007
+
+* new string conversion code (much faster; unlimited exponents)
+* fixed bug in factorial (it gave the wrong value, though gamma worked)
+* division now uses a rigorous algorithm for directed rounding
+  (mpmath previously used a heuristic that got the last bit wrong
+  in 1/10000 of cases)
+* misc. performance improvements (arithmetic is 15% faster)
+* refactored parts of the code; added many more docstrings and tests
+* added a function rand() for generating full-precision random numbers
+* rewrote the benchmark script to compare against Decimal and to
+  automatically generate timings with psyco both disabled and enabled
+* rewrote unit tests to use py.test
+
+--0.3--
+Released October 5, 2007
+
+* fixed high-precision accuracy problem in complex sqrt
+* fixed high-precision accuracy problem in atan and complex log
+* fixed directed rounding for sqrt (always rounded to nearest)
+* implemented all hyperbolic and inverse functions (there are some
+  accuracy issues left to sort out)
+* included gamma, factorial, erf, zeta incomplete gamma functions
+* made sin and tan more accurate for complex input very close to 0
+* more docstrings
+* many more tests
+* including a benchmark script
+
+-- 0.2 --
+Released October 2, 2007
+
+* 50% faster exponential function
+* faster mpf <-> int ops
+* fixed import error in pidigits.py; added demos to source distribution
+* __rmul__ was missing on mpf
+* fixed bitcount bug also for -(2**n-1)
+* more docstrings
+* more tests; tests included in source distribution
+* approximate equality testing (.ae method) supported
+* implemented atan and atan2 functions
+* tan works for both mpfs and mpcs
+* complex logarithms and complex powers supported
+* more details in README
+
+-- 0.1 --
+Released September 27, 2007
+
+* imported code from SymPy's numerics module
+* renamed functions and restructured various parts of the code
+* fixed erroneous bitcount for 2**n-1 mantissa with directed rounding
+* various small speed improvements and bug fixes

mpmath/source/CITATION.bib

@@ -0,0 +1,7 @@
+@manual{mpmath,
+  key     = {mpmath},
+  author  = {The mpmath development team},
+  title   = {mpmath: a {P}ython library for arbitrary-precision floating-point arithmetic (version 1.4.0)},
+  note    = {{\tt https://mpmath.org/}},
+  year    = {2026},
+}

mpmath/source/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2005-2026 Fredrik Johansson and mpmath contributors
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of the copyright holder nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.

mpmath/source/README.rst

@@ -0,0 +1,188 @@
+mpmath
+======
+
+|pypi version| |Build status| |Zenodo Badge|
+
+.. |pypi version| image:: https://img.shields.io/pypi/v/mpmath.svg
+   :target: https://pypi.python.org/pypi/mpmath
+.. |Build status| image:: https://github.com/mpmath/mpmath/workflows/test/badge.svg
+   :target: https://github.com/mpmath/mpmath/actions?workflow=test
+.. |Zenodo Badge| image:: https://zenodo.org/badge/2934512.svg
+   :target: https://zenodo.org/badge/latestdoi/2934512
+
+A Python library for arbitrary-precision floating-point arithmetic.
+
+Website: https://mpmath.org/
+Main author: Fredrik Johansson <fredrik.johansson@gmail.com>
+
+Mpmath is free software released under the New BSD License (see the
+LICENSE file for details).
+
+0. History and credits
+----------------------
+
+The following people (among others) have contributed major patches
+or new features to mpmath:
+
+* Pearu Peterson <pearu.peterson@gmail.com>
+* Mario Pernici <mario.pernici@mi.infn.it>
+* Ondrej Certik <ondrej@certik.cz>
+* Vinzent Steinberg <vinzent.steinberg@gmail.com>
+* Nimish Telang <ntelang@gmail.com>
+* Mike Taschuk <mtaschuk@ece.ualberta.ca>
+* Case Van Horsen <casevh@gmail.com>
+* Jorn Baayen <jorn.baayen@gmail.com>
+* Chris Smith <smichr@gmail.com>
+* Juan Arias de Reyna <arias@us.es>
+* Ioannis Tziakos <itziakos@gmail.com>
+* Aaron Meurer <asmeurer@gmail.com>
+* Stefan Krastanov <krastanov.stefan@gmail.com>
+* Ken Allen <ken.allen@sbcglobal.net>
+* Timo Hartmann <thartmann15@gmail.com>
+* Sergey B Kirpichev <skirpichev@gmail.com>
+* Kris Kuhlman <kristopher.kuhlman@gmail.com>
+* Paul Masson <paulmasson@analyticphysics.com>
+* Michael Kagalenko <michael.kagalenko@gmail.com>
+* Jonathan Warner <warnerjon12@gmail.com>
+* Max Gaukler <max.gaukler@fau.de>
+* Guillermo Navas-Palencia <g.navas.palencia@gmail.com>
+* Nike Dattani <nike@hpqc.org>
+* Tim Peters <tim.peters@gmail.com>
+* Javier Garcia <javier.garcia.tw@hotmail.com>
+
+Numerous other people have contributed by reporting bugs,
+requesting new features, or suggesting improvements to the
+documentation.
+
+For a detailed changelog, including individual contributions,
+see the CHANGES file.
+
+Fredrik's work on mpmath during summer 2008 was sponsored by Google
+as part of the Google Summer of Code program.
+
+Fredrik's work on mpmath during summer 2009 was sponsored by the
+American Institute of Mathematics under the support of the National Science
+Foundation Grant No. 0757627 (FRG: L-functions and Modular Forms).
+
+Any opinions, findings, and conclusions or recommendations expressed in this
+material are those of the author(s) and do not necessarily reflect the
+views of the sponsors.
+
+Credit also goes to:
+
+* The authors of the GMP library and the Python wrapper
+  gmpy, enabling mpmath to become much faster at
+  high precision
+* The authors of MPFR, pari/gp, MPFUN, and other arbitrary-
+  precision libraries, whose documentation has been helpful
+  for implementing many of the algorithms in mpmath
+* Wikipedia contributors; Abramowitz & Stegun; Gradshteyn & Ryzhik;
+  Wolfram Research for MathWorld and the Wolfram Functions site.
+  These are the main references used for special functions
+  implementations.
+* George Brandl for developing the Sphinx documentation tool
+  used to build mpmath's documentation
+
+Release history:
+
+* Version 1.4.0 released on February 23, 2026
+* Version 1.3.0 released on March 7, 2023
+* Version 1.2.1 released on February 9, 2021
+* Version 1.2.0 released on February 1, 2021
+* Version 1.1.0 released on December 11, 2018
+* Version 1.0.0 released on September 27, 2017
+* Version 0.19 released on June 10, 2014
+* Version 0.18 released on December 31, 2013
+* Version 0.17 released on February 1, 2011
+* Version 0.16 released on September 24, 2010
+* Version 0.15 released on June 6, 2010
+* Version 0.14 released on February 5, 2010
+* Version 0.13 released on August 13, 2009
+* Version 0.12 released on June 9, 2009
+* Version 0.11 released on January 26, 2009
+* Version 0.10 released on October 15, 2008
+* Version 0.9 released on August 23, 2008
+* Version 0.8 released on April 20, 2008
+* Version 0.7 released on March 12, 2008
+* Version 0.6 released on January 13, 2008
+* Version 0.5 released on November 24, 2007
+* Version 0.4 released on November 3, 2007
+* Version 0.3 released on October 5, 2007
+* Version 0.2 released on October 2, 2007
+* Version 0.1 released on September 27, 2007
+
+1. Download & installation
+--------------------------
+
+Mpmath requires Python 3.10 or later versions.  It has been tested with CPython
+3.10 through 3.14 and for PyPy 3.11.
+
+The latest release of mpmath can be downloaded from the mpmath
+website and from https://github.com/mpmath/mpmath/releases
+
+It should also be available in the Python Package Index at
+https://pypi.python.org/pypi/mpmath
+
+To install latest release of Mpmath with pip, simply run
+
+``pip install mpmath``
+
+or from the source tree
+
+``pip install .``
+
+The latest development code is available from
+https://github.com/mpmath/mpmath
+
+See the main documentation for more detailed instructions.
+
+2. Documentation
+----------------
+
+Documentation in reStructuredText format is available in the
+docs directory included with the source package. These files
+are human-readable, but can be compiled to prettier HTML using
+`Sphinx <https://www.sphinx-doc.org/>`_.
+
+The most recent documentation is also available in HTML format:
+
+https://mpmath.readthedocs.io/
+
+3. Running tests
+----------------
+
+The unit tests in mpmath/tests/ can be run with `pytest
+<https://pytest.org/>`_, see the main documentation.
+
+You may also want to check out the demo scripts in the demo
+directory.
+
+The master branch is automatically tested on the Github Actions.
+
+4. Known problems
+-----------------
+
+Mpmath is a work in progress. Major issues include:
+
+* Some functions may return incorrect values when given extremely
+  large arguments or arguments very close to singularities.
+
+* Directed rounding works for arithmetic operations. It is implemented
+  heuristically for other operations, and their results may be off by one
+  or two units in the last place (even if otherwise accurate).
+
+* Some IEEE 754 features are not available. Inifinities and NaN are
+  partially supported, there is no signed zero; denormal rounding is
+  not available at all.
+
+* The interface for switching precision and rounding is not finalized.
+  The current method is not threadsafe.
+
+5. Help and bug reports
+-----------------------
+
+General questions and comments can be `sent <mailto:mpmath@googlegroups.com>`_
+to the `mpmath mailinglist <https://groups.google.com/g/mpmath>`_.
+
+You can also report bugs and send patches to the mpmath issue tracker,
+https://github.com/mpmath/mpmath/issues

mpmath/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+mpmath Project Package Initialization File
+"""

mpmath/source/conftest.py

@@ -0,0 +1,26 @@
+import sys
+
+import pytest
+
+import mpmath
+
+
+def pytest_report_header(config):
+    print("mpmath backend: %s" % mpmath.libmp.backend.BACKEND)
+    print("mpmath mp class: %s" % repr(mpmath.mp))
+    print("mpmath version: %s" % mpmath.__version__)
+    print("Python version: %s" % sys.version)
+
+
+def pytest_configure(config):
+    config.addinivalue_line('markers', 'slow: marks tests as slow')
+
+
+@pytest.fixture(autouse=True)
+def reset_mp_globals():
+    mpmath.mp.prec = sys.float_info.mant_dig
+    mpmath.mp.pretty = False
+    mpmath.mp.rounding = 'n'
+    mpmath.mp.pretty_dps = "str"
+    mpmath.iv.prec = mpmath.mp.prec
+    mpmath.iv.pretty = False

mpmath/source/demo/mandelbrot.py

@@ -0,0 +1,33 @@
+"""
+This script uses the cplot function in mpmath to plot the Mandelbrot set.
+By default, the fp context is used for speed. The mp context could be used
+to improve accuracy at extremely high zoom levels.
+"""
+
+import mpmath
+
+ctx = mpmath.fp
+# ctx = mpmath.mp
+
+ITERATIONS = 50
+POINTS = 100000
+ESCAPE_RADIUS = 8
+
+# Full plot
+RE = [-2.5, 1.5]
+IM = [-1.5, 1.5]
+
+# A pretty subplot
+#RE = [-0.96, -0.80]
+#IM = [-0.35, -0.2]
+
+def mandelbrot(z):
+    c = z
+    for i in range(ITERATIONS):
+        zprev = z
+        z = z*z + c
+        if abs(z) > ESCAPE_RADIUS:
+            return ctx.exp(1j*(i + 1 - ctx.log(ctx.log(abs(z)))/ctx.log(2)))
+    return 0
+
+ctx.cplot(mandelbrot, RE, IM, points=POINTS, verbose=1)

mpmath/source/demo/manydigits.py

@@ -0,0 +1,104 @@
+"""
+This script calculates solutions to some of the problems from the
+"Many Digits" competition:
+http://www.cs.ru.nl/~milad/manydigits/problems.php
+
+Run with:
+
+    python manydigits.py
+
+"""
+from mpmath import (mp, sin, tan, cos, sqrt, e, pi, exp, atanh, mpf, tanh,
+                    zeta, catalan, findroot, quadts, atan, asin, asinh)
+from mpmath.libmp import to_fixed, bin_to_radix
+
+dps = 100
+mp.dps = dps + 10
+
+def pr(x):
+    """Return the first dps digits after the decimal point"""
+    x = x._mpf_
+    p = int(dps*3.33 + 10)
+    t = to_fixed(x, p)
+    d = bin_to_radix(t, p, 10, dps)
+    s = str(d).zfill(dps)[-dps:]
+    return s[:dps//2] + "\n" + s[dps//2:]
+
+print("""
+This script prints answers to a selection of the "Many Digits"
+competition problems: http://www.cs.ru.nl/~milad/manydigits/problems.php
+
+The output for each problem is the first 100 digits after the
+decimal point in the result.
+""")
+
+print("C01: sin(tan(cos(1)))")
+print(pr(sin(tan(cos(1)))))
+print()
+
+print("C02: sqrt(e/pi)")
+print(pr(sqrt(e/pi)))
+print()
+
+print("C03: sin((e+1)^3)")
+print(pr(sin((e+1)**3)))
+print()
+
+print("C04: exp(pi*sqrt(2011))")
+mp.dps += 65
+print(pr(exp(pi*sqrt(2011))))
+mp.dps -= 65
+print()
+
+print("C05: exp(exp(exp(1/2)))")
+print(pr(exp(exp(exp(0.5)))))
+print()
+
+print("C06: arctanh(1-arctanh(1-arctanh(1-arctanh(1/pi))))")
+print(pr(atanh(1-atanh(1-atanh(1-atanh(1/pi))))))
+print()
+
+print("C07: pi^1000")
+mp.dps += 505
+print(pr(pi**1000))
+mp.dps -= 505
+print()
+
+print("C08: sin(6^(6^6))")
+print(pr(sin(6**(6**6))))
+print()
+
+print("C09: sin(10*arctan(tanh(pi*(2011^(1/2))/3)))")
+mp.dps += 150
+print(pr(sin(10*atan(tanh(pi*sqrt(2011)/3)))))
+mp.dps -= 150
+print()
+
+print("C10: (7+2^(1/5)-5*(8^(1/5)))^(1/3) + 4^(1/5)-2^(1/5)")
+a = mpf(1)/5
+print(pr(((7 + 2**a - 5*(8**a))**(mpf(1)/3) + 4**a - 2**a)))
+print()
+
+print("C11: tan(2^(1/2))+arctanh(sin(1))")
+print(pr((tan(sqrt(2)) + atanh(sin(1)))))
+print()
+
+print("C12: arcsin(1/e^2) + arcsinh(e^2)")
+print(pr(asin(1/exp(2)) + asinh(exp(2))))
+print()
+
+print("C17: S= -4*Zeta(2) - 2*Zeta(3) + 4*Zeta(2)*Zeta(3) + 2*Zeta(5)")
+print(pr(-4*zeta(2) - 2*zeta(3) + 4*zeta(2)*zeta(3) + 2*zeta(5)))
+print()
+
+print(r"C18: Catalan G = Sum{i=0}{\infty}(-1)^i/(2i+1)^2")
+print(pr(catalan))
+print()
+
+print("C21: Equation exp(cos(x)) = x")
+print(pr(findroot(lambda x: exp(cos(x))-x, 1)))
+print()
+
+print("C22: J = integral(sin(sin(sin(x)))), x=0..1")
+print(pr(quadts(lambda x: sin(sin(sin(x))), [0, 1])))
+print()

mpmath/source/demo/pidigits.py

@@ -0,0 +1,80 @@
+"""
+Calculate digits of pi. This module can be run interactively with
+
+    python pidigits.py
+
+"""
+
+import sys
+import math
+from time import perf_counter
+
+from mpmath.libmp import bin_to_radix, numeral, pi_fixed
+
+def display_fraction(digits, skip=0, colwidth=10, columns=5):
+    perline = colwidth * columns
+    printed = 0
+    for linecount in range((len(digits)-skip) // (colwidth * columns)):
+        line = digits[skip+linecount*perline:skip+(linecount+1)*perline]
+        for i in range(columns):
+            print(line[i*colwidth : (i+1)*colwidth], end=' ')
+        print(":", (linecount+1)*perline)
+        if (linecount+1) % 10 == 0:
+            print()
+        printed += colwidth*columns
+    rem = (len(digits)-skip) % (colwidth * columns)
+    if rem:
+        buf = digits[-rem:]
+        s = ""
+        for i in range(columns):
+            s += buf[:colwidth].ljust(colwidth+1, " ")
+            buf = buf[colwidth:]
+        print(s + ":", printed + colwidth*columns)
+
+def calculateit(base, n, tofile):
+    intpart = numeral(3, base)
+    skip = 1
+    if base <= 3:
+        skip = 2
+
+    prec = int(n*math.log(base,2))+10
+
+    print("Step 1 of 2: calculating binary value...")
+    t = perf_counter()
+    a = pi_fixed(prec, verbose=True, verbose_base=base)
+    step1_time = perf_counter() - t
+
+    print("Step 2 of 2: converting to specified base...")
+    t = perf_counter()
+    d = bin_to_radix(a, prec, base, n)
+    d = numeral(d, base, n)
+    step2_time = perf_counter() - t
+
+    print("\nWriting output...\n")
+
+    if tofile:
+        out_ = sys.stdout
+        sys.stdout = tofile
+    print("%i base-%i digits of pi:\n" % (n, base))
+    print(intpart, ".\n")
+
+    display_fraction(d, skip, colwidth=10, columns=5)
+    if tofile:
+        sys.stdout = out_
+    print("\nFinished in %f seconds (%f calc, %f convert)" % \
+        ((step1_time + step2_time), step1_time, step2_time))
+
+def interactive():
+    print("Compute digits of pi with mpmath\n")
+    base = input("Which base? (2-36, 10 for decimal) \n> ")
+    digits = input("How many digits? (enter a big number, say, 10000)\n> ")
+    tofile = input("Output to file? (enter a filename, or just press " \
+        "enter\nto print directly to the screen) \n> ")
+    if tofile:
+        tofile = open(tofile, "w")
+
+    calculateit(int(base), int(digits), tofile)
+    input("\nPress enter to close this script.")
+
+if __name__ == "__main__":
+    interactive()

mpmath/source/demo/plotting.py

@@ -0,0 +1,35 @@
+"""
+Function plotting demo.
+"""
+from mpmath import *
+
+def main():
+    print("""
+    Simple function plotting. You can enter one or several
+    formulas, in ordinary Python syntax and using the mpmath
+    function library. The variable is 'x'. So for example
+    the input "sin(x/2)" (without quotation marks) defines
+    a valid function.
+    """)
+    functions = []
+    for i in range(10):
+        if i == 0:
+            s = input('Enter a function: ')
+        else:
+            s = input('Enter another function (optional): ')
+        if not s:
+            print()
+            break
+        f = eval("lambda x: " + s)
+        functions.append(f)
+        print("Added f(x) = " + s)
+        print()
+    xlim = input('Enter xmin, xmax (optional): ')
+    if xlim:
+        xlim = eval(xlim)
+    else:
+        xlim = [-5, 5]
+    print("Plotting...")
+    plot(functions, xlim=xlim)
+
+main()

mpmath/source/demo/sofa.py

@@ -0,0 +1,63 @@
+'''
+This script calculates the constant in Gerver's solution to the moving sofa
+problem.
+
+See Finch, S. R. "Moving Sofa Constant." §8.12 in Mathematical Constants.
+Cambridge, England: Cambridge University Press, pp. 519-523, 2003.
+'''
+
+from mpmath import cos, sin, pi, quad, findroot, mp
+
+mp.prec = 113
+
+eqs = [lambda A, B, φ, θ: (A*(cos(θ) - cos(φ)) - 2*B*sin(φ)
+                           + (θ - φ - 1)*cos(θ) - sin(θ) + cos(φ) + sin(φ)),
+       lambda A, B, φ, θ: (A*(3*sin(θ) + sin(φ)) - 2*B*cos(φ)
+                           + 3*(θ - φ - 1)*sin(θ) + 3*cos(θ) - sin(φ) + cos(φ)),
+       lambda A, B, φ, θ: A*cos(φ) - (sin(φ) + 0.5 - 0.5*cos(φ) + B*sin(φ)),
+       lambda A, B, φ, θ: ((A + pi/2 - φ - θ) - (B - (θ - φ)*(1 + A)/2
+                                                 - 0.25*(θ - φ)**2))]
+A, B, φ, θ = findroot(eqs, (0, 0, 0, 0))
+
+def r(α):
+    if 0 <= α < φ:
+        return 0.5
+    if φ <= α < θ:
+        return (1 + A + α - φ)/2
+    if θ <= α < pi/2 - θ:
+        return A + α - φ
+    return B - (pi/2 - α - φ)*(1 + A)/2 - (pi/2 - α - φ)**2/4
+
+s = lambda α: 1 - r(α)
+
+def u(α):
+    if φ <= α < θ:
+        return B - (α - φ)*(1 + A)/2 - (α - φ)**2/4
+    return A + pi/2 - φ - α
+
+def du(α):
+    if φ <= α < θ:
+        return -(1 + A)/2 - (α - φ)/2
+    return -1
+
+def y(α, f):
+    if α > pi/2 - θ:
+        i = [0, φ, θ, pi/2 - θ, α]
+    elif α > θ:
+        i = [0, φ, θ, α]
+    elif α > φ:
+        i = [0, φ, α]
+    else:
+        i = i = [0, α]
+    return 1 - quad(lambda x: f(x)*sin(x), i)
+
+y1 = lambda α: y(α, r)
+y2 = lambda α: y(α, s)
+y3 = lambda α: y2(α) - u(α)*sin(α)
+
+S1 = quad(lambda x: y1(x)*r(x)*cos(x), [0, φ, θ, pi/2 - θ, pi/2 - φ])
+S2 = quad(lambda x: y2(x)*s(x)*cos(x), [0, φ, θ])
+S3 = quad(lambda x: y3(x)*(u(x)*sin(x) - du(x)*cos(x) - s(x)*cos(x)),
+          [φ, θ, pi/4])
+
+print(2*(S1 + S2 + S3))

mpmath/source/demo/taylor.py

@@ -0,0 +1,71 @@
+"""
+Interval arithmetic demo: estimating error of numerical Taylor series.
+
+This module can be run interactively with
+
+    python taylor.py
+
+"""
+from mpmath import mpi, exp, factorial, mpf
+
+def taylor(x, n):
+    print("-"*75)
+    t = x = mpi(x)
+    s = 1
+    print("adding 1")
+    print(s, "\n")
+    s += t
+    print("adding x")
+    print(s, "\n")
+    for k in range(2, n+1):
+        t = (t * x) / k
+        s += t
+        print("adding x^%i / %i! ~= %s" % (k, k, t.mid))
+        print(s, "\n")
+    print("-"*75)
+    return s
+
+# Note: this should really be computed using interval arithmetic too!
+def remainder(x, n):
+    xi = max(0, x)
+    r = exp(xi) / factorial(n+1)
+    r = r * x**(n+1)
+    return abs(r)
+
+def exponential(x, n):
+    """
+    Compute exp(x) using n terms of the Taylor series for exp using
+    intervals, and print detailed error analysis.
+    """
+    t = taylor(x, n)
+    r = remainder(x, n)
+    expx = exp(x)
+    print("Correct value of exp(x):    ", expx)
+    print()
+    print("Computed interval:          ")
+    print(t)
+    print()
+    print("Computed value (midpoint):  ", t.mid)
+    print()
+    print("Estimated rounding error:   ", t.delta)
+    print("Estimated truncation error: ", r)
+    print("Estimated total error:      ", t.delta + r)
+    print("Actual error                ", abs(expx - t.mid))
+    print()
+    u = t + mpi(-r, r)
+    print("Interval with est. truncation error added:")
+    print(u)
+    print()
+    print("Correct value contained in computed interval:", t.a <= expx <= t.b)
+    print("When accounting for truncation error:", u.a <= expx <= u.b)
+
+if __name__ == "__main__":
+    print("Interval arithmetic demo")
+    print()
+    print("This script sums the Taylor series for exp(x) using interval arithmetic,")
+    print("and then compares the numerical errors due to rounding and truncation.")
+    print()
+    x = mpf(input("Enter the value of x (e.g. 3.5): "))
+    n = int(input("Enter the number of terms n (e.g. 10): "))
+    print()
+    exponential(x, n)

mpmath/source/docs/basics.rst

@@ -0,0 +1,253 @@
+Basic usage
+===========================
+
+To avoid inadvertently overriding other functions or objects, explicitly import
+only the needed objects, or use the ``mpmath.`` or ``mp.`` namespaces::
+
+    >>> from mpmath import sin
+    >>> sin(1)
+    mpf('0.8414709848078965')
+
+    >>> import mpmath
+    >>> mpmath.sin(1)
+    mpf('0.8414709848078965')
+
+    >>> from mpmath import mp  # mp context object -- to be explained
+    >>> mp.sin(1)
+    mpf('0.8414709848078965')
+
+.. note::
+
+   Importing everything with ``from mpmath import *`` can be convenient,
+   especially when using mpmath interactively, but is best to avoid such
+   import statements in production code, as they make it unclear which
+   names are present in the namespace and wildcard-imported names may
+   conflict with other modules or variable names.
+
+Number types
+------------
+
+Mpmath provides the following numerical types:
+
+    +------------+----------------+
+    | Class      | Description    |
+    +============+================+
+    | ``mpf``    | Real float     |
+    +------------+----------------+
+    | ``mpc``    | Complex float  |
+    +------------+----------------+
+    | ``matrix`` | Matrix         |
+    +------------+----------------+
+
+The following section will provide a very short introduction to the types ``mpf`` and ``mpc``. Intervals and matrices are described further in the documentation chapters on interval arithmetic and matrices / linear algebra.
+
+The ``mpf`` type is analogous to Python's built-in ``float``. It holds a real number or one of the special values ``inf`` (positive infinity), ``-inf`` (negative infinity) and ``nan`` (not-a-number, indicating an indeterminate result). You can create ``mpf`` instances from strings, integers, floats, and other ``mpf`` instances:
+
+    >>> from mpmath import mpf, mpc, mp
+    >>> mpf(4)
+    mpf('4.0')
+    >>> mpf(2.5)
+    mpf('2.5')
+    >>> mpf("1.25e6")
+    mpf('1250000.0')
+    >>> mpf(mpf(2))
+    mpf('2.0')
+    >>> mpf("inf")
+    mpf('inf')
+
+The ``mpc`` type represents a complex number in rectangular form as a pair of ``mpf`` instances. It can be constructed from a Python ``complex``, a real number, or a pair of real numbers:
+
+    >>> mpc(2,3)
+    mpc(real='2.0', imag='3.0')
+    >>> mpc(complex(2,3)).imag
+    mpf('3.0')
+
+You can mix ``mpf`` and ``mpc`` instances with each other and with Python numbers:
+
+    >>> mpf(3) + 2*mpf('2.5') + 1.0
+    mpf('9.0')
+    >>> mp.dps = 15      # Set precision (see below)
+    >>> mpc(1j)**0.5
+    mpc(real='0.70710678118654757', imag='0.70710678118654757')
+
+
+Setting the precision
+---------------------
+
+Mpmath uses a global working precision; it does not keep track of the precision or accuracy of individual numbers. Performing an arithmetic operation or calling ``mpf()`` rounds the result to the current working precision. The working precision is controlled by a context object called ``mp``, which has the following default state:
+
+    >>> print(mp)
+    Mpmath settings:
+      mp.prec = 53                [default: 53]
+      mp.dps = 15                 [default: 15]
+      mp.rounding = 'n'           [default: 'n']
+      mp.trap_complex = False     [default: False]
+
+The term **prec** denotes the binary precision (measured in bits) while **dps** (short for *decimal places*) is the decimal precision. Binary and decimal precision are related roughly according to the formula ``prec = 3.33*dps``. For example, it takes a precision of roughly 333 bits to hold an approximation of pi that is accurate to 100 decimal places (actually slightly more than 333 bits is used).
+
+Changing either precision property of the ``mp`` object automatically updates the other; usually you just want to change the ``dps`` value:
+
+    >>> mp.dps = 100
+    >>> mp.dps
+    100
+    >>> mp.prec
+    336
+
+When the precision has been set, all ``mpf`` operations are carried out at that precision::
+
+    >>> mp.dps = 50
+    >>> mpf(1) / 6
+    mpf('0.16666666666666666666666666666666666666666666666666656')
+    >>> mp.dps = 25
+    >>> mpf(2) ** mpf('0.5')
+    mpf('1.414213562373095048801688713')
+
+The precision of complex arithmetic is also controlled by the ``mp`` object:
+
+    >>> mp.dps = 10
+    >>> mpc(1,2) / 3
+    mpc(real='0.3333333333321', imag='0.6666666666642')
+
+There is no restriction on the magnitude of numbers. An ``mpf`` can for example hold an approximation of a large Mersenne prime:
+
+    >>> mp.dps = 15
+    >>> print(mpf(2)**32582657 - 1)
+    1.24575026015369e+9808357
+
+Or why not 1 googolplex:
+
+    >>> print(mpf(10) ** (10**100))
+    1.0e+100000000000000000000000000000000000000000000000000...
+
+The (binary) exponent is stored exactly and is independent of the precision.
+
+The ``rounding`` property control default rounding mode for the context:
+
+    >>> mp.rounding  # round to nearest
+    'n'
+    >>> sin(1)
+    mpf('0.8414709848078965')
+    >>> mp.rounding = 'u'  # round up
+    >>> sin(1)
+    mpf('0.84147098480789662')
+    >>> mp.rounding = 'n'
+
+Temporarily changing the precision
+..................................
+
+It is often useful to change the precision during only part of a calculation. A way to temporarily increase the precision and then restore it is as follows:
+
+    >>> mp.prec += 2
+    >>> # do_something()
+    >>> mp.prec -= 2
+
+The ``with`` statement along with the mpmath functions ``workprec``, ``workdps``, ``extraprec`` and ``extradps`` can be used to temporarily change precision in a more safe manner:
+
+    >>> from mpmath import extradps, workdps
+    >>> with workdps(20):
+    ...     print(mpf(1)/7)
+    ...     with extradps(10):
+    ...         print(mpf(1)/7)
+    ...
+    0.14285714285714285714
+    0.142857142857142857142857142857
+    >>> mp.dps
+    15
+
+The ``with`` statement ensures that the precision gets reset when exiting the block, even in the case that an exception is raised.
+
+The ``workprec`` family of functions can also be used as function decorators:
+
+    >>> @workdps(6)
+    ... def f():
+    ...     return mpf(1)/3
+    ...
+    >>> f()
+    mpf('0.33333331346511841')
+
+
+Some functions accept the ``prec`` and ``dps`` keyword arguments and this will override the global working precision. Note that this will not affect the precision at which the result is printed, so to get all digits, you must either use increase precision afterward when printing or use ``nstr``/``nprint``:
+
+    >>> from mpmath import exp, nprint
+    >>> mp.dps = 15
+    >>> print(exp(1))
+    2.71828182845905
+    >>> print(exp(1, dps=50))      # Extra digits won't be printed
+    2.71828182845905
+    >>> nprint(exp(1, dps=50), 50)
+    2.7182818284590452353602874713526624977572470937
+
+Finally, instead of using the global context object ``mp``, you can create custom contexts and work with methods of those instances instead of global functions. The working precision will be local to each context object:
+
+    >>> mp2 = mp.clone()
+    >>> mp.dps = 10
+    >>> mp2.dps = 20
+    >>> print(mp.mpf(1) / 3)
+    0.3333333333
+    >>> print(mp2.mpf(1) / 3)
+    0.33333333333333333333
+
+**Note**: the ability to create multiple contexts is a new feature that is only partially implemented. Not all mpmath functions are yet available as context-local methods. In the present version, you are likely to encounter bugs if you try mixing different contexts.
+
+Providing correct input
+-----------------------
+
+Note that when creating a new ``mpf``, the value will at most be as accurate as the input. *Be careful when mixing mpmath numbers with Python floats*. When working at high precision, fractional ``mpf`` values should be created from strings or integers:
+
+    >>> mp.dps = 30
+    >>> mpf(10.9)   # bad
+    mpf('10.9000000000000003552713678800501')
+    >>> mpf(1090/100)  # bad, beware Python's true division produces floats
+    mpf('10.9000000000000003552713678800501')
+    >>> mpf('10.9')  # good
+    mpf('10.8999999999999999999999999999997')
+    >>> mpf(109) / mpf(10)   # also good
+    mpf('10.8999999999999999999999999999997')
+    >>> mp.dps = 15
+
+(Binary fractions such as 0.5, 1.5, 0.75, 0.125, etc, are generally safe as input, however, since those can be represented exactly by Python floats.)
+
+Printing
+--------
+
+By default, the ``repr()`` of a number includes its type signature. This way ``eval`` can be used to recreate a number from its string representation:
+
+    >>> eval(repr(mpf(2.5)))
+    mpf('2.5')
+
+Prettier output can be obtained by using ``str()`` or ``print``, which hide the ``mpf`` and ``mpc`` signatures and also suppress rounding artifacts in the last few digits:
+
+    >>> mpf("3.14159")
+    mpf('3.1415899999999999')
+    >>> print(mpf("3.14159"))
+    3.14159
+    >>> print(mpc(1j)**0.5)
+    (0.707106781186548 + 0.707106781186548j)
+
+Setting the ``mp.pretty`` option will use the ``str()``-style output for ``repr()`` as well:
+
+    >>> mp.pretty = True
+    >>> mpf(0.6)
+    0.6
+    >>> mp.pretty = False
+    >>> mpf(0.6)
+    mpf('0.59999999999999998')
+
+To use enough digits to be able recreate value exactly, set ``mp.pretty_dps``
+to ``"repr"`` (default value is ``"str"``).  Same option is used to control
+default number of digits in the new-style string formatting *without format
+specifier*, i.e. ``format(exp(mpf(1)))``.
+
+The number of digits with which numbers are printed by default is determined by
+the working precision.  To specify the number of digits to show without
+changing the working precision, use :func:`format syntax support
+<mpmath.mpf.__format__>` or functions :func:`mpmath.nstr` and
+:func:`mpmath.nprint`:
+
+    >>> a = mpf(1) / 6
+    >>> a
+    mpf('0.16666666666666666')
+    >>> f'{a:.8}'
+    '0.16666667'
+    >>> f'{a:.50}'
+    '0.16666666666666665741480812812369549646973609924316'

mpmath/source/docs/calculus/approximation.rst

@@ -0,0 +1,23 @@
+Function approximation
+----------------------
+
+Taylor series (``taylor``)
+..........................
+
+.. autofunction:: mpmath.taylor
+
+Pade approximation (``pade``)
+.............................
+
+.. autofunction:: mpmath.pade
+
+Chebyshev approximation (``chebyfit``)
+......................................
+
+.. autofunction:: mpmath.chebyfit
+
+Fourier series (``fourier``, ``fourierval``)
+............................................
+
+.. autofunction:: mpmath.fourier
+.. autofunction:: mpmath.fourierval

mpmath/source/docs/calculus/differentiation.rst

@@ -0,0 +1,19 @@
+Differentiation
+---------------
+
+Numerical derivatives (``diff``, ``diffs``)
+...........................................
+
+.. autofunction:: mpmath.diff
+.. autofunction:: mpmath.diffs
+
+Composition of derivatives (``diffs_prod``, ``diffs_exp``)
+..........................................................
+
+.. autofunction:: mpmath.diffs_prod
+.. autofunction:: mpmath.diffs_exp
+
+Fractional derivatives / differintegration (``differint``)
+............................................................
+
+.. autofunction:: mpmath.differint

mpmath/source/docs/calculus/index.rst

@@ -0,0 +1,14 @@
+Numerical calculus
+==================
+
+.. toctree::
+   :maxdepth: 2
+
+   polynomials
+   optimization
+   sums_limits
+   differentiation
+   integration
+   odes
+   approximation
+   inverselaplace

mpmath/source/docs/calculus/integration.rst

@@ -0,0 +1,36 @@
+Numerical integration (quadrature)
+----------------------------------
+
+Standard quadrature (``quad``)
+..............................
+
+.. autofunction:: mpmath.quad
+
+Quadrature with subdivision (``quadsubdiv``)
+............................................
+
+.. autofunction:: mpmath.quadsubdiv
+
+Oscillatory quadrature (``quadosc``)
+....................................
+
+.. autofunction:: mpmath.quadosc
+
+Quadrature rules
+................
+
+.. autoclass:: mpmath.calculus.quadrature.QuadratureRule
+   :members:
+
+Tanh-sinh rule
+~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.quadrature.TanhSinh
+   :members:
+
+
+Gauss-Legendre rule
+~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.quadrature.GaussLegendre
+   :members:

mpmath/source/docs/calculus/inverselaplace.rst

@@ -0,0 +1,71 @@
+Numerical inverse Laplace transform
+-----------------------------------
+
+One-step algorithm (``invertlaplace``)
+......................................
+
+.. autofunction:: mpmath.invertlaplace
+
+Specific algorithms
+...................
+
+Fixed Talbot algorithm
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.inverselaplace.FixedTalbot
+   :members:
+
+Gaver-Stehfest algorithm
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.inverselaplace.Stehfest
+   :members:
+
+de Hoog, Knight & Stokes algorithm
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.inverselaplace.deHoog
+   :members:
+
+Cohen acceleration algorithm
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: mpmath.calculus.inverselaplace.Cohen
+   :members:
+
+Manual approach
+...............
+
+It is possible and sometimes beneficial to re-create some of the
+functionality in ``invertlaplace``. This could be used to compute the
+Laplace-space function evaluations in a different way.  For example,
+the Laplace-space function evaluations could be the result of a
+quadrature or sum, solution to a system of ordinary differential
+equations, or possibly computed in parallel from some external library
+or function call.
+
+A trivial example showing the process (which could be implemented
+using the existing interface):
+
+>>> from mpmath import calculus, convert, exp, mp
+>>> myTalbot = calculus.inverselaplace.FixedTalbot(mp)
+>>> t = convert(0.25)
+>>> myTalbot.calc_laplace_parameter(t)
+>>> fp = lambda p: 1/(p + 1) - 1/(p + 1000)
+>>> ft = lambda t: exp(-t) - exp(-1000*t)
+>>> fpvec = [fp(p) for p in myTalbot.p]
+>>> ft(t)-myTalbot.calc_time_domain_solution(fpvec,t,manual_prec=True)
+mpf('1.928300179528890061756872185e-21')
+
+This manual approach is also useful to look at the Laplace parameter,
+order, or working precision which were computed.
+
+>>> myTalbot.degree
+34
+
+Credit
+......
+
+The numerical inverse Laplace transform functionality was contributed
+to mpmath by Kristopher L. Kuhlman in 2017. The Cohen method was contributed
+to mpmath by Guillermo Navas-Palencia in 2022.

mpmath/source/docs/calculus/odes.rst

@@ -0,0 +1,7 @@
+Ordinary differential equations
+-------------------------------
+
+Solving the ODE initial value problem (``odefun``)
+..................................................
+
+.. autofunction:: mpmath.odefun

mpmath/source/docs/calculus/optimization.rst

@@ -0,0 +1,23 @@
+Root-finding and optimization
+-----------------------------
+
+Root-finding (``findroot``)
+...........................
+
+.. autofunction:: mpmath.findroot(f, x0, solver=Secant, tol=None, verbose=False, verify=True, **kwargs)
+
+Solvers
+^^^^^^^
+
+.. autoclass:: mpmath.calculus.optimization.Secant
+.. autoclass:: mpmath.calculus.optimization.Newton
+.. autoclass:: mpmath.calculus.optimization.MNewton
+.. autoclass:: mpmath.calculus.optimization.Halley
+.. autoclass:: mpmath.calculus.optimization.Muller
+.. autoclass:: mpmath.calculus.optimization.Bisection
+.. autoclass:: mpmath.calculus.optimization.Illinois
+.. autoclass:: mpmath.calculus.optimization.Pegasus
+.. autoclass:: mpmath.calculus.optimization.Anderson
+.. autoclass:: mpmath.calculus.optimization.Ridder
+.. autoclass:: mpmath.calculus.optimization.ANewton
+.. autoclass:: mpmath.calculus.optimization.MDNewton

mpmath/source/docs/calculus/polynomials.rst

@@ -0,0 +1,15 @@
+Polynomials
+-----------
+
+See also :func:`~mpmath.taylor` and :func:`~mpmath.chebyfit` for
+approximation of functions by polynomials.
+
+Polynomial evaluation (``polyval``)
+...................................
+
+.. autofunction:: mpmath.polyval
+
+Polynomial roots (``polyroots``)
+................................
+
+.. autofunction:: mpmath.polyroots

mpmath/source/docs/calculus/sums_limits.rst

@@ -0,0 +1,67 @@
+Sums, products, limits and extrapolation
+----------------------------------------
+
+The functions listed here permit approximation of infinite
+sums, products, and other sequence limits.
+Use :func:`mpmath.fsum` and :func:`mpmath.fprod`
+for summation and multiplication of finite sequences.
+
+Summation
+..........................................
+
+:func:`~mpmath.nsum`
+^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.nsum
+
+:func:`~mpmath.sumem`
+^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.sumem
+
+:func:`~mpmath.sumap`
+^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.sumap
+
+Products
+...............................
+
+:func:`~mpmath.nprod`
+^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.nprod
+
+Limits (``limit``)
+..................
+
+:func:`~mpmath.limit`
+^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.limit
+
+Extrapolation
+..........................................
+
+The following functions provide a direct interface to
+extrapolation algorithms. :func:`~mpmath.nsum` and :func:`~mpmath.limit`
+essentially work by calling the following functions with an increasing
+number of terms until the extrapolated limit is accurate enough.
+
+The following functions may be useful to call directly if the
+precise number of terms needed to achieve a desired accuracy is
+known in advance, or if one wishes to study the convergence
+properties of the algorithms.
+
+
+:func:`~mpmath.richardson`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.richardson
+
+:func:`~mpmath.shanks`
+^^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.shanks
+
+:func:`~mpmath.levin`
+^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.levin
+
+:func:`~mpmath.cohen_alt`
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autofunction:: mpmath.cohen_alt
+

mpmath/source/docs/cli.rst

@@ -0,0 +1,8 @@
+.. _cli:
+
+Command-Line Usage
+==================
+
+When called as a program from the command line, the following form is used:
+
+.. autoprogram:: mpmath.__main__:parser

mpmath/source/docs/conf.py

@@ -0,0 +1,52 @@
+"""
+Mpmath documentation build configuration file.
+
+This file is execfile()d with the current directory set to its
+containing dir.
+
+The contents of this file are pickled, so don't put values in the
+namespace that aren't pickleable (module imports are okay, they're
+removed automatically).
+"""
+
+import mpmath
+
+
+# Add any Sphinx extension module names here, as strings.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.mathjax',
+              'sphinx.ext.intersphinx', 'sphinxcontrib.autoprogram',
+              'matplotlib.sphinxext.plot_directive']
+
+# Sphinx will warn about all references where the target cannot be found.
+nitpicky = True
+
+# Project information.
+project = mpmath.__name__
+copyright = '2007-2026, Fredrik Johansson and mpmath developers'
+release = version = mpmath.__version__
+
+# Define how the current time is formatted using time.strftime().
+today_fmt = '%B %d, %Y'
+
+# The "theme" that the HTML output should use.
+html_theme = 'classic'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = [('index', 'mpmath.tex', 'mpmath documentation',
+                    r'Fredrik Johansson \and mpmath contributors', 'manual')]
+
+# The name of default reST role, that is, for text marked up `like this`.
+default_role = 'math'
+
+# Contains mapping the locations and names of other projects that
+# should be linked to in this documentation.
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/3/', None),
+    'sympy': ('https://docs.sympy.org/latest/', None),
+}
+
+plot_include_source = True
+plot_formats = [('png', 96), 'pdf']
+plot_html_show_formats = False
+plot_html_show_source_link = False

mpmath/source/docs/contexts.rst

@@ -0,0 +1,370 @@
+Contexts
+========
+
+High-level code in mpmath is implemented as methods on a "context object". The context implements arithmetic, type conversions and other fundamental operations. The context also holds settings such as precision, and stores cache data. A few different contexts (with a mostly compatible interface) are provided so that the high-level algorithms can be used with different implementations of the underlying arithmetic, allowing different features and speed-accuracy tradeoffs. Currently, mpmath provides the following contexts:
+
+  * Arbitrary-precision arithmetic (``mp``)
+  * Arbitrary-precision interval arithmetic (``iv``)
+  * Double-precision arithmetic using Python's builtin ``float`` and ``complex`` types (``fp``)
+
+.. note::
+
+   Using global context is not thread-safe, create instead
+   local contexts with e.g. :class:`~mpmath.MPContext`.
+
+Most global functions in the global mpmath namespace are actually methods of the ``mp``
+context. This fact is usually transparent to the user, but sometimes shows up in the
+form of an initial parameter called "ctx" visible in the help for the function::
+
+    >>> import mpmath
+    >>> help(mpmath.fsum)
+    Help on method fsum in module mpmath.ctx_mp_python:
+    <BLANKLINE>
+    fsum(terms, absolute=False, squared=False) method of mpmath.ctx_mp.MPContext instance
+        Calculates a sum containing a finite number of terms (for infinite
+        series, see :func:`~mpmath.nsum`). The terms will be converted to
+    ...
+
+The following operations are equivalent::
+
+    >>> mpmath.fsum([1,2,3])
+    mpf('6.0')
+    >>> mpmath.mp.fsum([1,2,3])
+    mpf('6.0')
+
+The corresponding operation using the ``fp`` context::
+
+    >>> mpmath.fp.fsum([1,2,3])
+    6.0
+
+Common interface
+----------------
+
+``ctx.mpf`` creates a real number::
+
+    >>> from mpmath import mp, fp
+    >>> mp.mpf(3)
+    mpf('3.0')
+    >>> fp.mpf(3)
+    3.0
+
+``ctx.mpc`` creates a complex number::
+
+    >>> mp.mpc(2,3)
+    mpc(real='2.0', imag='3.0')
+    >>> fp.mpc(2,3)
+    (2+3j)
+
+``ctx.matrix`` creates a matrix::
+
+    >>> mp.matrix([[1,0],[0,1]])
+    matrix(
+    [['1.0', '0.0'],
+     ['0.0', '1.0']])
+    >>> _[0,0]
+    mpf('1.0')
+    >>> fp.matrix([[1,0],[0,1]])
+    matrix(
+    [['1.0', '0.0'],
+     ['0.0', '1.0']])
+    >>> _[0,0]
+    1.0
+
+``ctx.prec`` holds the current precision (in bits)::
+
+    >>> mp.prec
+    53
+    >>> fp.prec
+    53
+
+``ctx.dps`` holds the current precision (in digits)::
+
+    >>> mp.dps
+    15
+    >>> fp.dps
+    15
+
+``ctx.pretty`` controls whether objects should be pretty-printed automatically by :func:`repr`. Pretty-printing for ``mp`` numbers is disabled by default so that they can clearly be distinguished from Python numbers and so that ``eval(repr(x)) == x`` works::
+
+    >>> mp.mpf(3)
+    mpf('3.0')
+    >>> mpf = mp.mpf
+    >>> eval(repr(mp.mpf(3)))
+    mpf('3.0')
+    >>> mp.pretty = True
+    >>> mp.mpf(3)
+    3.0
+    >>> fp.matrix([[1,0],[0,1]])
+    matrix(
+    [['1.0', '0.0'],
+     ['0.0', '1.0']])
+    >>> fp.pretty = True
+    >>> fp.matrix([[1,0],[0,1]])
+    [1.0  0.0]
+    [0.0  1.0]
+    >>> fp.pretty = False
+
+
+Arbitrary-precision floating-point (``mp``)
+---------------------------------------------
+
+The ``mp`` context is what most users probably want to use most of the time, as it supports the most functions, is most well-tested, and is implemented with a high level of optimization. Nearly all examples in this documentation use ``mp`` functions.
+
+See :doc:`basics` for a description of basic usage.
+
+.. autoclass:: mpmath.MPContext
+
+Local contexts, created on demand, could be used just as the global ``mp``:
+
+    >>> from mpmath import MPContext
+    >>> ctx = MPContext()
+    >>> ctx.sin(1)
+    mpf('0.8414709848078965')
+    >>> ctx.prec = 113
+    >>> ctx.sin(1)
+    mpf('0.841470984807896506652502321630298954')
+
+Arbitrary-precision interval arithmetic (``iv``)
+------------------------------------------------
+
+The ``iv.mpf`` type represents a closed interval `[a,b]`; that is, the set `\{x : a \le x \le b\}`, where `a` and `b` are arbitrary-precision floating-point values, possibly `\pm \infty`. The ``iv.mpc`` type represents a rectangular complex interval `[a,b] + [c,d]i`; that is, the set `\{z = x+iy : a \le x \le b \land c \le y \le d\}`.
+
+Interval arithmetic provides rigorous error tracking. If `f` is a mathematical function and `\hat f` is its interval arithmetic version, then the basic guarantee of interval arithmetic is that `f(v) \subseteq \hat f(v)` for any input interval `v`. Put differently, if an interval represents the known uncertainty for a fixed number, any sequence of interval operations will produce an interval that contains what would be the result of applying the same sequence of operations to the exact number. The principal drawbacks of interval arithmetic are speed (``iv`` arithmetic is typically at least two times slower than ``mp`` arithmetic) and that it sometimes provides far too pessimistic bounds.
+
+.. note ::
+
+    The support for interval arithmetic in mpmath is still experimental, and many functions
+    do not yet properly support intervals. Please use this feature with caution.
+
+Intervals can be created from single numbers (treated as zero-width intervals) or pairs of endpoint numbers. Strings are treated as exact decimal numbers. Note that a Python float like ``0.1`` generally does not represent the same number as its literal; use ``'0.1'`` instead::
+
+    >>> from mpmath import iv
+    >>> iv.mpf(3)
+    mpi('3.0', '3.0')
+    >>> print(iv.mpf(3))
+    [3.0, 3.0]
+    >>> iv.pretty = True
+    >>> iv.mpf([2,3])
+    [2.0, 3.0]
+    >>> iv.mpf(0.1)   # probably not intended
+    [0.10000000000000000555, 0.10000000000000000555]
+    >>> iv.mpf('0.1')   # good, gives a containing interval
+    [0.099999999999999991673, 0.10000000000000000555]
+    >>> iv.mpf(['0.1', '0.2'])
+    [0.099999999999999991673, 0.2000000000000000111]
+
+The fact that ``'0.1'`` results in an interval of nonzero width indicates that 1/10 cannot be represented using binary floating-point numbers at this precision level (in fact, it cannot be represented exactly at any precision).
+
+Intervals may be infinite or half-infinite::
+
+    >>> print(1 / iv.mpf([2, 'inf']))
+    [0.0, 0.5]
+
+The equality testing operators ``==`` and ``!=`` check whether their operands
+are identical as intervals; that is, have the same endpoints. The ordering
+operators ``< <= > >=`` permit inequality testing using triple-valued logic: a
+guaranteed inequality returns ``True`` or ``False`` while an indeterminate
+inequality raises :exc:`ValueError`::
+
+    >>> iv.mpf([1,2]) == iv.mpf([1,2])
+    True
+    >>> iv.mpf([1,2]) != iv.mpf([1,2])
+    False
+    >>> iv.mpf([1,2]) <= 2
+    True
+    >>> iv.mpf([1,2]) > 0
+    True
+    >>> iv.mpf([1,2]) < 1
+    False
+    >>> iv.mpf([1,2]) < 2
+    Traceback (most recent call last):
+      ...
+    ValueError
+    >>> iv.mpf([2,2]) < 2
+    False
+    >>> iv.mpf([1,2]) <= iv.mpf([2,3])
+    True
+    >>> iv.mpf([1,2]) < iv.mpf([2,3])
+    Traceback (most recent call last):
+      ...
+    ValueError
+    >>> iv.mpf([1,2]) < iv.mpf([-1,0])
+    False
+
+The ``in`` operator tests whether a number or interval is contained in another interval::
+
+    >>> iv.mpf([0,2]) in iv.mpf([0,10])
+    True
+    >>> 3 in iv.mpf(['-inf', 0])
+    False
+
+Intervals have the properties ``.a``, ``.b`` (endpoints), ``.mid``, and ``.delta`` (width)::
+
+    >>> x = iv.mpf([2, 5])
+    >>> x.a
+    [2.0, 2.0]
+    >>> x.b
+    [5.0, 5.0]
+    >>> x.mid
+    [3.5, 3.5]
+    >>> x.delta
+    [3.0, 3.0]
+
+Some transcendental functions are supported::
+
+    >>> iv.dps = 15
+    >>> mp.dps = 15
+    >>> iv.mpf([0.5,1.5]) ** iv.mpf([0.5, 1.5])
+    [0.35355339059327373086, 1.837117307087383633]
+    >>> iv.exp(0)
+    [1.0, 1.0]
+    >>> iv.exp(['-inf','inf'])
+    [0.0, inf]
+    >>>
+    >>> iv.exp(['-inf',0])
+    [0.0, 1.0]
+    >>> iv.exp([0,'inf'])
+    [1.0, inf]
+    >>> iv.exp([0,1])
+    [1.0, 2.7182818284590455349]
+    >>>
+    >>> iv.log(1)
+    [0.0, 0.0]
+    >>> iv.log([0,1])
+    [-inf, 0.0]
+    >>> iv.log([0,'inf'])
+    [-inf, inf]
+    >>> iv.log(2)
+    [0.69314718055994528623, 0.69314718055994539725]
+    >>>
+    >>> iv.sin([100,'inf'])
+    [-1.0, 1.0]
+    >>> iv.cos(['-0.1','0.1'])
+    [0.99500416527802570954, 1.0]
+
+Interval arithmetic is useful for proving inequalities involving irrational numbers.
+Naive use of ``mp`` arithmetic may result in wrong conclusions, such as the following::
+
+    >>> mp.dps = 25
+    >>> x = mp.exp(mp.pi*mp.sqrt(163))
+    >>> y = mp.mpf(640320**3+744)
+    >>> print(x)
+    262537412640768744.0000001
+    >>> print(y)
+    262537412640768744.0
+    >>> x > y
+    True
+
+But the correct result is `e^{\pi \sqrt{163}} < 262537412640768744`, as can be
+seen by increasing the precision::
+
+    >>> mp.dps = 50
+    >>> print(mp.exp(mp.pi*mp.sqrt(163)))
+    262537412640768743.99999999999925007259719818568888
+
+With interval arithmetic, the comparison raises :exc:`ValueError` until the
+precision is large enough for `x-y` to have a definite sign::
+
+    >>> iv.dps = 15
+    >>> iv.exp(iv.pi*iv.sqrt(163)) > (640320**3+744)
+    Traceback (most recent call last):
+      ...
+    ValueError
+    >>> iv.dps = 30
+    >>> iv.exp(iv.pi*iv.sqrt(163)) > (640320**3+744)
+    Traceback (most recent call last):
+      ...
+    ValueError
+    >>> iv.dps = 60
+    >>> iv.exp(iv.pi*iv.sqrt(163)) > (640320**3+744)
+    False
+    >>> iv.dps = 15
+
+Fast low-precision arithmetic (``fp``)
+---------------------------------------------
+
+Although mpmath is generally designed for arbitrary-precision arithmetic, many of the high-level algorithms work perfectly well with ordinary Python ``float`` and ``complex`` numbers, which use hardware double precision (on most systems, this corresponds to 53 bits of precision). Whereas the global functions (which are methods of the ``mp`` object) always convert inputs to mpmath numbers, the ``fp`` object instead converts them to ``float`` or ``complex``, and in some cases employs basic functions optimized for double precision. When large amounts of function evaluations (numerical integration, plotting, etc) are required, and when ``fp`` arithmetic provides sufficient accuracy, this can give a significant speedup over ``mp`` arithmetic.
+
+To take advantage of this feature, simply use the ``fp`` prefix, i.e. write ``fp.func`` instead of ``func`` or ``mp.func``::
+
+    >>> u = fp.erfc(0.5)
+    >>> print(u)
+    0.4795001221869535
+    >>> type(u)
+    <class 'float'>
+    >>> mp.dps = 16
+    >>> print(mp.erfc(0.5))
+    0.4795001221869535
+    >>> fp.matrix([[1,2],[3,4]]) ** 2
+    matrix(
+    [['7.0', '10.0'],
+     ['15.0', '22.0']])
+    >>>
+    >>> type(_[0,0])
+    <class 'float'>
+    >>> print(fp.quad(fp.sin, [0, fp.pi]))    # numerical integration
+    2.0
+
+The ``fp`` context wraps Python's ``math`` and ``cmath`` modules for elementary functions. It supports both real and complex numbers and automatically generates complex results for real inputs (``math`` raises an exception)::
+
+    >>> fp.sqrt(5)
+    2.23606797749979
+    >>> fp.sqrt(-5)
+    2.23606797749979j
+    >>> fp.sin(10)
+    -0.5440211108893698
+    >>> fp.power(-1, 0.25)
+    (0.7071067811865476+0.7071067811865475j)
+    >>> (-1) ** 0.25
+    (0.7071067811865476+0.7071067811865475j)
+
+The ``prec`` and ``dps`` attributes can be changed (for interface compatibility with the ``mp`` context) but this has no effect::
+
+    >>> fp.prec
+    53
+    >>> fp.dps
+    15
+    >>> fp.prec = 80
+    >>> fp.prec
+    53
+    >>> fp.dps
+    15
+
+Due to intermediate rounding and cancellation errors, results computed with ``fp`` arithmetic may be much less accurate than those computed with ``mp`` using an equivalent precision (``mp.prec = 53``), since the latter often uses increased internal precision. The accuracy is highly problem-dependent: for some functions, ``fp`` almost always gives 14-15 correct digits; for others, results can be accurate to only 2-3 digits or even completely wrong. The recommended use for ``fp`` is therefore to speed up large-scale computations where accuracy can be verified in advance on a subset of the input set, or where results can be verified afterwards.
+
+Beware that the ``fp`` context has signed zero, that can be used to distinguish
+different sides of branch cuts.  For example, ``fp.mpc(-1, -0.0)`` is treated
+as though it lies *below* the branch cut for :func:`~mpmath.sqrt()`::
+
+    >>> fp.sqrt(fp.mpc(-1, -0.0))
+    -1j
+    >>> fp.sqrt(fp.mpc(-1, -1e-10))
+    (5e-11-1j)
+
+But an argument of ``fp.mpc(-1, 0.0)`` is treated as though it lies *above* the
+branch cut::
+
+    >>> fp.sqrt(fp.mpc(-1, +0.0))
+    1j
+    >>> fp.sqrt(fp.mpc(-1, +1e-10))
+    (5e-11+1j)
+
+
+While near the branch cut, for small but nonzero deviations in components
+results agreed with the ``mp`` contexts::
+
+    >>> fp.mpc(mp.sqrt(mp.mpc(-1, -1e-10)))
+    (5e-11-1j)
+    >>> fp.mpc(mp.sqrt(mp.mpc(-1, +1e-10)))
+    (5e-11+1j)
+
+one has no signed zeros and allows to specify result *on the branch cut*
+(nonpositive part of the real axis in this example)::
+
+    >>> fp.mpc(mp.sqrt(mp.mpc(-1, 0)))
+    1j
+    >>> fp.mpc(mp.sqrt(-1))
+    1j
+
+Here it's continuous from the above of the :func:`~mpmath.sqrt()` branch
+cut (from ``0`` along the negative real axis to the negative infinity).

mpmath/source/docs/functions/bessel.rst

@@ -0,0 +1,106 @@
+Bessel functions and related functions
+--------------------------------------
+
+The functions in this section arise as solutions to various differential
+equations in physics, typically describing wavelike oscillatory behavior or a
+combination of oscillation and exponential decay or growth.  Mathematically,
+they are special cases of the confluent hypergeometric functions `\,_0F_1`,
+`\,_1F_1` and `\,_1F_2` (see :doc:`hypergeometric`).
+
+
+Bessel functions
+................
+
+.. autofunction:: mpmath.besselj
+.. autofunction:: mpmath.j0
+.. autofunction:: mpmath.j1
+.. autofunction:: mpmath.bessely
+.. autofunction:: mpmath.besseli
+.. autofunction:: mpmath.besselk
+
+
+Bessel function zeros
+.....................
+
+.. autofunction:: mpmath.besseljzero
+.. autofunction:: mpmath.besselyzero
+
+
+Hankel functions
+................
+
+.. autofunction:: mpmath.hankel1
+.. autofunction:: mpmath.hankel2
+
+
+Spherical Bessel functions
+..........................
+
+.. autofunction:: mpmath.spherical_jn
+.. autofunction:: mpmath.spherical_yn
+
+
+Kelvin functions
+................
+
+.. autofunction:: mpmath.ber
+.. autofunction:: mpmath.bei
+.. autofunction:: mpmath.ker
+.. autofunction:: mpmath.kei
+
+
+Struve functions
+................
+
+.. autofunction:: mpmath.struveh
+.. autofunction:: mpmath.struvel
+
+
+Anger-Weber functions
+.....................
+
+.. autofunction:: mpmath.angerj
+.. autofunction:: mpmath.webere
+
+
+Lommel functions
+................
+
+.. autofunction:: mpmath.lommels1
+.. autofunction:: mpmath.lommels2
+
+
+Airy and Scorer functions
+.........................
+
+.. autofunction:: mpmath.airyai
+.. autofunction:: mpmath.airybi
+.. autofunction:: mpmath.airyaizero
+.. autofunction:: mpmath.airybizero
+.. autofunction:: mpmath.scorergi
+.. autofunction:: mpmath.scorerhi
+
+
+Coulomb wave functions
+......................
+
+.. autofunction:: mpmath.coulombf
+.. autofunction:: mpmath.coulombg
+.. autofunction:: mpmath.coulombc
+
+
+Confluent U and Whittaker functions
+...................................
+
+.. autofunction:: mpmath.hyperu(a, b, z)
+.. autofunction:: mpmath.whitm(k,m,z)
+.. autofunction:: mpmath.whitw(k,m,z)
+
+
+Parabolic cylinder functions
+............................
+
+.. autofunction:: mpmath.pcfd
+.. autofunction:: mpmath.pcfu
+.. autofunction:: mpmath.pcfv
+.. autofunction:: mpmath.pcfw

mpmath/source/docs/functions/constants.rst

@@ -0,0 +1,45 @@
+Mathematical constants
+----------------------
+
+Mpmath supports arbitrary-precision computation of various common (and less
+common) mathematical constants.  These constants are implemented as lazy
+objects that can evaluate to any precision.  Whenever the objects are used as
+function arguments or as operands in arithmetic operations, they automagically
+evaluate to the current working precision.  A lazy number can be converted to a
+regular ``mpf`` using the unary ``+`` operator, or by calling it as a
+function::
+
+    >>> from mpmath import pi, mp
+    >>> pi
+    <pi: 3.14159~>
+    >>> 2*pi
+    mpf('6.2831853071795862')
+    >>> +pi
+    mpf('3.1415926535897931')
+    >>> pi()
+    mpf('3.1415926535897931')
+    >>> mp.dps = 40
+    >>> pi
+    <pi: 3.14159~>
+    >>> 2*pi
+    mpf('6.283185307179586476925286766559005768394338')
+    >>> +pi
+    mpf('3.141592653589793238462643383279502884197169')
+    >>> pi()
+    mpf('3.141592653589793238462643383279502884197169')
+
+The predefined objects ``j`` (imaginary unit), ``inf`` (positive infinity) and
+``nan`` (not-a-number) are shortcuts to ``mpc`` and ``mpf`` instances with
+these fixed values.
+
+.. autofunction:: mpmath.mp.pi
+.. autoattribute:: mpmath.mp.degree
+.. autoattribute:: mpmath.mp.e
+.. autoattribute:: mpmath.mp.phi
+.. autofunction:: mpmath.mp.euler
+.. autoattribute:: mpmath.mp.catalan
+.. autoattribute:: mpmath.mp.apery
+.. autoattribute:: mpmath.mp.khinchin
+.. autoattribute:: mpmath.mp.glaisher
+.. autoattribute:: mpmath.mp.mertens
+.. autoattribute:: mpmath.mp.twinprime

mpmath/source/docs/functions/elliptic.rst

@@ -0,0 +1,53 @@
+Elliptic functions
+------------------
+
+.. automodule:: mpmath.functions.elliptic
+   :no-index:
+
+
+Elliptic arguments
+..................
+
+.. autofunction:: mpmath.qfrom
+.. autofunction:: mpmath.qbarfrom
+.. autofunction:: mpmath.mfrom
+.. autofunction:: mpmath.kfrom
+.. autofunction:: mpmath.taufrom
+
+
+Legendre elliptic integrals
+...........................
+
+.. autofunction:: mpmath.ellipk
+.. autofunction:: mpmath.ellipf
+.. autofunction:: mpmath.ellipe
+.. autofunction:: mpmath.ellippi
+
+
+Carlson symmetric elliptic integrals
+....................................
+
+.. autofunction:: mpmath.elliprf
+.. autofunction:: mpmath.elliprc
+.. autofunction:: mpmath.elliprj
+.. autofunction:: mpmath.elliprd
+.. autofunction:: mpmath.elliprg
+
+
+Jacobi theta functions
+......................
+
+.. autofunction:: mpmath.jtheta
+
+
+Jacobi elliptic functions
+.........................
+
+.. autofunction:: mpmath.ellipfun
+
+
+Modular functions
+.................
+
+.. autofunction:: mpmath.eta
+.. autofunction:: mpmath.kleinj

mpmath/source/docs/functions/expintegrals.rst

@@ -0,0 +1,70 @@
+Exponential integrals and error functions
+-----------------------------------------
+
+Exponential integrals give closed-form solutions to a large class of commonly
+occurring transcendental integrals that cannot be evaluated using elementary
+functions.  Integrals of this type include those with an integrand of the form
+`t^a e^{t}` or `e^{-x^2}`, the latter giving rise to the Gaussian (or normal)
+probability distribution.
+
+The most general function in this section is the incomplete gamma function, to
+which all others can be reduced.  The incomplete gamma function, in turn, can
+be expressed using hypergeometric functions (see :doc:`hypergeometric`).
+
+Incomplete gamma functions
+..........................
+
+.. autofunction:: mpmath.gammainc
+.. autofunction:: mpmath.lower_gamma
+.. autofunction:: mpmath.upper_gamma
+
+
+Exponential integrals
+.....................
+
+.. autofunction:: mpmath.ei
+.. autofunction:: mpmath.e1
+.. autofunction:: mpmath.expint
+
+
+Logarithmic integral
+....................
+
+.. autofunction:: mpmath.li
+
+
+Trigonometric integrals
+.......................
+
+.. autofunction:: mpmath.ci
+.. autofunction:: mpmath.si
+
+
+Hyperbolic integrals
+....................
+
+.. autofunction:: mpmath.chi
+.. autofunction:: mpmath.shi
+
+
+Error functions
+...............
+
+.. autofunction:: mpmath.erf
+.. autofunction:: mpmath.erfc
+.. autofunction:: mpmath.erfi
+.. autofunction:: mpmath.erfinv
+
+
+The normal distribution
+.......................
+
+.. autofunction:: mpmath.npdf
+.. autofunction:: mpmath.ncdf
+
+
+Fresnel integrals
+.................
+
+.. autofunction:: mpmath.fresnels
+.. autofunction:: mpmath.fresnelc

mpmath/source/docs/functions/gamma.rst

@@ -0,0 +1,79 @@
+Factorials and gamma functions
+------------------------------
+
+Factorials and factorial-like sums and products are basic tools of
+combinatorics and number theory.  Much like the exponential function is
+fundamental to differential equations and analysis in general, the factorial
+function (and its extension to complex numbers, the gamma function) is
+fundamental to difference equations and functional equations.
+
+A large selection of factorial-like functions is implemented in mpmath.  All
+functions support complex arguments, and arguments may be arbitrarily large.
+Results are numerical approximations, so to compute *exact* values a high
+enough precision must be set manually::
+
+    >>> from mpmath import mp, fac
+    >>> mp.dps = 15
+    >>> mp.pretty = True
+    >>> fac(100)
+    9.33262154439442e+157
+    >>> print(int(_))    # most digits are wrong
+    93326215443944150965646704795953882578400970373184098831012889540582227238570431295066113089288327277825849664006524270554535976289719382852181865895959724032
+    >>> mp.dps = 160
+    >>> fac(100)
+    93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000.0
+
+The gamma and polygamma functions are closely related to :doc:`zeta`.  See also
+:doc:`qfunctions` for q-analogs of factorial-like functions.
+
+
+Factorials
+..........
+
+.. autofunction:: mpmath.factorial
+.. autofunction:: mpmath.fac2
+
+
+Binomial coefficients
+.....................
+
+.. autofunction:: mpmath.binomial
+
+
+Gamma function
+..............
+
+.. autofunction:: mpmath.gamma
+.. autofunction:: mpmath.rgamma
+.. autofunction:: mpmath.gammaprod
+.. autofunction:: mpmath.loggamma
+
+
+Rising and falling factorials
+.............................
+
+.. autofunction:: mpmath.rf
+.. autofunction:: mpmath.ff
+
+
+Beta function
+.............
+
+.. autofunction:: mpmath.beta
+.. autofunction:: mpmath.betainc
+
+
+Super- and hyperfactorials
+..........................
+
+.. autofunction:: mpmath.superfac
+.. autofunction:: mpmath.hyperfac
+.. autofunction:: mpmath.barnesg
+
+
+Polygamma functions and harmonic numbers
+........................................
+
+.. autofunction:: mpmath.psi
+.. autofunction:: mpmath.digamma
+.. autofunction:: mpmath.harmonic

mpmath/source/docs/functions/hyperbolic.rst

@@ -0,0 +1,23 @@
+Hyperbolic functions
+--------------------
+
+Hyperbolic functions
+....................
+
+.. autofunction:: mpmath.cosh
+.. autofunction:: mpmath.sinh
+.. autofunction:: mpmath.tanh
+.. autofunction:: mpmath.sech
+.. autofunction:: mpmath.csch
+.. autofunction:: mpmath.coth
+
+
+Inverse hyperbolic functions
+............................
+
+.. autofunction:: mpmath.acosh
+.. autofunction:: mpmath.asinh
+.. autofunction:: mpmath.atanh
+.. autofunction:: mpmath.asech
+.. autofunction:: mpmath.acsch
+.. autofunction:: mpmath.acoth

mpmath/source/docs/functions/hypergeometric.rst

@@ -0,0 +1,74 @@
+Hypergeometric functions
+------------------------
+
+The functions listed in :doc:`expintegrals`, :doc:`bessel` and
+:doc:`orthogonal`, and many other functions as well, are merely particular
+instances of the generalized hypergeometric function `\,_pF_q`.  The functions
+listed in the following section enable efficient direct evaluation of the
+underlying hypergeometric series, as well as linear combinations, limits with
+respect to parameters, and analytic continuations thereof.  Extensions to
+twodimensional series are also provided.  See also the basic or q-analog of the
+hypergeometric series in :doc:`qfunctions`.
+
+For convenience, most of the hypergeometric series of low order are provided as
+standalone functions.  They can equivalently be evaluated using
+:func:`~mpmath.hyper`.  As will be demonstrated in the respective docstrings,
+all the ``hyp#f#`` functions implement analytic continuations and/or asymptotic
+expansions with respect to the argument `z`, thereby permitting evaluation for
+`z` anywhere in the complex plane.  Functions of higher degree can be computed
+via :func:`~mpmath.hyper`, but generally only in rapidly convergent instances.
+
+Most hypergeometric and hypergeometric-derived functions accept optional
+keyword arguments to specify options for :func:`~mpmath.hypercomb` or
+:func:`~mpmath.hyper`.  Some useful options are *maxprec*, *maxterms*,
+*zeroprec*, *accurate_small*, *hmag*, *force_series*, *asymp_tol* and
+*eliminate*.  These options give control over what to do in case of slow
+convergence, extreme loss of accuracy or evaluation at zeros (these two cases
+cannot generally be distinguished from each other automatically), and singular
+parameter combinations.
+
+Common hypergeometric series
+............................
+
+.. autofunction:: mpmath.hyp0f1
+.. autofunction:: mpmath.hyp1f1
+.. autofunction:: mpmath.hyp1f2
+.. autofunction:: mpmath.hyp2f0
+.. autofunction:: mpmath.hyp2f1
+.. autofunction:: mpmath.hyp2f2
+.. autofunction:: mpmath.hyp2f3
+.. autofunction:: mpmath.hyp3f2
+
+
+Generalized hypergeometric functions
+....................................
+
+.. autofunction:: mpmath.hyper
+.. autofunction:: mpmath.hypercomb
+
+
+Meijer G-function
+.................
+
+.. autofunction:: mpmath.meijerg
+
+Fox H-function
+.................
+
+.. autofunction:: mpmath.foxh
+
+
+Bilateral hypergeometric series
+...............................
+
+.. autofunction:: mpmath.bihyper
+
+
+Hypergeometric functions of two variables
+.........................................
+
+.. autofunction:: mpmath.hyper2d
+.. autofunction:: mpmath.appellf1
+.. autofunction:: mpmath.appellf2
+.. autofunction:: mpmath.appellf3
+.. autofunction:: mpmath.appellf4

mpmath/source/docs/functions/index.rst

@@ -0,0 +1,22 @@
+Mathematical functions
+======================
+
+Mpmath implements the standard functions from Python's ``math`` and ``cmath`` modules, for both real and complex numbers and with arbitrary precision. Many other functions are also available in mpmath, including commonly-used variants of standard functions (such as the alternative trigonometric functions sec, csc, cot), but also a large number of "special functions" such as the gamma function, the Riemann zeta function, error functions, Bessel functions, etc.
+
+.. toctree::
+   :maxdepth: 2
+
+   constants
+   powers
+   trigonometric
+   hyperbolic
+   signals
+   gamma
+   expintegrals
+   bessel
+   orthogonal
+   hypergeometric
+   elliptic
+   zeta
+   numtheory
+   qfunctions

mpmath/source/docs/functions/numtheory.rst

@@ -0,0 +1,58 @@
+Number-theoretical, combinatorial and integer functions
+-------------------------------------------------------
+
+For factorial-type functions, including binomial coefficients, double
+factorials, etc, see the separate section :doc:`gamma`.
+
+Fibonacci numbers
+.................
+
+.. autofunction:: mpmath.fibonacci
+
+
+Bernoulli numbers and polynomials
+.................................
+
+.. autofunction:: mpmath.bernoulli
+.. autofunction:: mpmath.bernfrac
+.. autofunction:: mpmath.bernpoly
+
+
+Euler numbers and polynomials
+.............................
+
+.. autofunction:: mpmath.eulernum
+.. autofunction:: mpmath.eulerpoly
+
+
+Bell numbers and polynomials
+............................
+
+.. autofunction:: mpmath.bell
+
+
+Stirling numbers
+................
+
+.. autofunction:: mpmath.stirling1
+.. autofunction:: mpmath.stirling2
+
+
+Prime counting functions
+........................
+
+.. autofunction:: mpmath.primepi
+.. autofunction:: mpmath.primepi2
+.. autofunction:: mpmath.riemannr
+
+
+Cyclotomic polynomials
+......................
+
+.. autofunction:: mpmath.cyclotomic
+
+
+Arithmetic functions
+......................
+
+.. autofunction:: mpmath.mangoldt