0
# mpmath
1
2
A comprehensive Python library for arbitrary-precision floating-point arithmetic. mpmath provides a complete mathematical computing environment with support for real numbers, complex numbers, interval arithmetic, matrices, and advanced mathematical functions with configurable precision levels.
3
4
## Overview
5
6
mpmath enables computational mathematics with arbitrary precision in Python, serving researchers, engineers, and scientists who need exact numerical results beyond standard floating-point limitations. Key features include:
7
8
- **Arbitrary Precision Arithmetic**: Perform calculations with hundreds or thousands of decimal places
9
- **Comprehensive Mathematical Functions**: Complete implementation of elementary functions, special functions, and advanced mathematical operations
10
- **Multiple Number Systems**: Support for real numbers (mpf), complex numbers (mpc), and interval arithmetic (mpi)
11
- **Scientific Computing Tools**: Numerical integration, differentiation, root finding, linear algebra, and differential equations
12
- **Mathematical Constants**: High-precision values of π, e, and other important mathematical constants
13
- **Specialized Functions**: Gamma functions, Bessel functions, elliptic functions, hypergeometric functions, and more
14
- **Visualization Support**: Built-in plotting capabilities for mathematical functions and complex analysis
15
- **Flexible Precision Control**: Dynamic precision adjustment with context managers for optimal performance
16
17
mpmath is designed for applications requiring mathematical rigor, including symbolic computation, numerical analysis, mathematical research, and educational purposes where exact results are essential.
18
19
## Package Information
20
21
- **Package Name**: mpmath
22
- **Language**: Python
23
- **Installation**: `pip install mpmath`
24
25
## Core Imports
26
27
```python
28
import mpmath
29
```
30
31
For multiprecision arithmetic:
32
33
```python
34
from mpmath import mp, mpf, mpc
35
```
36
37
For convenience access to functions:
38
39
```python
40
from mpmath import *
41
```
42
43
## Basic Usage
44
45
```python
46
import mpmath
47
from mpmath import mp, mpf, mpc
48
49
# Set precision to 50 decimal places
50
mp.dps = 50
51
52
# Create high-precision numbers
53
x = mpf('1.23456789012345678901234567890')
54
y = mpf('2.71828182845904523536028747135')
55
56
# Basic arithmetic
57
result = x + y
58
print(f"Sum: {result}")
59
60
# Mathematical functions with high precision
61
pi_precise = mp.pi
62
e_precise = mp.e
63
sqrt_result = mp.sqrt(2)
64
65
print(f"π with 50 digits: {pi_precise}")
66
print(f"√2 with 50 digits: {sqrt_result}")
67
68
# Complex numbers
69
z = mpc('1+2j')
70
w = mpc('3-4j')
71
complex_result = z * w
72
print(f"Complex multiplication: {complex_result}")
73
74
# Advanced functions
75
gamma_result = mp.gamma(0.5) # Should equal √π
76
bessel_result = mp.besselj(0, 1)
77
print(f"Γ(0.5) = {gamma_result}")
78
print(f"J₀(1) = {bessel_result}")
79
```
80
81
## Architecture
82
83
mpmath is built around context objects that manage precision settings and provide mathematical functions:
84
85
- **MPContext (mp)**: Multiprecision arithmetic with configurable precision
86
- **FPContext (fp)**: Fast double-precision floating-point arithmetic
87
- **MPIntervalContext (iv)**: Interval arithmetic for rigorous numerical computation
88
89
The library provides three main number types:
90
91
- **mpf**: Multiprecision floating-point numbers
92
- **mpc**: Multiprecision complex numbers
93
- **mpi**: Multiprecision intervals
94
95
All mathematical functions support both real and complex arguments where mathematically meaningful, and precision can be adjusted globally or locally using context managers.
96
97
## Capabilities
98
99
### Core Number Types and Arithmetic
100
101
Basic number types, arithmetic operations, precision control, and utility functions. These form the foundation for all mathematical computations in mpmath.
102
103
```python { .api }
104
class mpf:
105
def __init__(self, x): ...
106
107
class mpc:
108
def __init__(self, real, imag=0): ...
109
110
def mpmath.convert(x): ...
111
def extraprec(n): ...
112
def workprec(n): ...
113
```
114
115
[Core Arithmetic](./core-arithmetic.md)
116
117
### Elementary Functions
118
119
Standard mathematical functions including exponentials, logarithms, trigonometric functions, hyperbolic functions, and basic operations on complex numbers.
120
121
```python { .api }
122
def sqrt(x): ...
123
def exp(x): ...
124
def log(x): ...
125
def sin(x): ...
126
def cos(x): ...
127
def tan(x): ...
128
```
129
130
[Elementary Functions](./elementary-functions.md)
131
132
### Special Functions
133
134
Advanced mathematical functions including gamma functions, zeta functions, Bessel functions, hypergeometric functions, elliptic functions, and other special functions from mathematical physics and number theory.
135
136
```python { .api }
137
def gamma(x): ...
138
def zeta(s): ...
139
def besselj(n, x): ...
140
def hyper(a_s, b_s, z): ...
141
def ellipk(m): ...
142
def erf(x): ...
143
```
144
145
[Special Functions](./special-functions.md)
146
147
### Linear Algebra and Matrices
148
149
Matrix operations, linear system solving, eigenvalue computations, matrix decompositions, and matrix functions supporting arbitrary precision arithmetic.
150
151
```python { .api }
152
class matrix:
153
def __init__(self, *args): ...
154
155
def lu_solve(A, b): ...
156
def qr(A): ...
157
def eig(A): ...
158
def det(A): ...
159
def norm(x): ...
160
```
161
162
[Linear Algebra](./linear-algebra.md)
163
164
### Numerical Calculus
165
166
Numerical integration, differentiation, root finding, optimization, series summation, and differential equation solving with high precision.
167
168
```python { .api }
169
def quad(f, a, b): ...
170
def diff(f, x): ...
171
def findroot(f, x0): ...
172
def nsum(f, n1, n2): ...
173
def taylor(f, x, n): ...
174
```
175
176
[Numerical Calculus](./numerical-calculus.md)
177
178
### Mathematical Constants
179
180
High-precision mathematical constants including π, e, and various special constants from number theory and analysis.
181
182
```python { .api }
183
mp.pi # π
184
mp.e # Euler's number
185
mp.euler # Euler-Mascheroni constant γ
186
mp.catalan # Catalan's constant
187
mp.phi # Golden ratio φ
188
```
189
190
[Mathematical Constants](./mathematical-constants.md)
191
192
### Elliptic Functions and Modular Forms
193
194
Elliptic functions, modular forms, theta functions, and q-analog functions for advanced mathematical applications including algebraic geometry, number theory, and mathematical physics.
195
196
```python { .api }
197
def jacobi(kind, u, m): ...
198
def jtheta(n, z, q): ...
199
def kleinj(tau): ...
200
def eta(tau): ...
201
def qp(a, q, n): ...
202
def qhyper(a_s, b_s, q, z): ...
203
```
204
205
[Elliptic Functions and Modular Forms](./elliptic-modular-functions.md)
206
207
### Visualization and Plotting
208
209
Plotting and visualization functions for mathematical functions, complex analysis, and numerical data with arbitrary precision support.
210
211
```python { .api }
212
def plot(f, xlim=[-5, 5]): ...
213
def cplot(f, re=[-2, 2], im=[-2, 2]): ...
214
def splot(f, u=[-2, 2], v=[-2, 2]): ...
215
```
216
217
[Visualization and Plotting](./visualization.md)
218
219
### Pattern Recognition and Mathematical Identification
220
221
Tools for identifying mathematical constants, finding integer relations, polynomial fitting, and discovering mathematical patterns in numerical data.
222
223
```python { .api }
224
def pslq(x, tol=None): ...
225
def identify(x, constants=None): ...
226
def findpoly(roots, tol=None): ...
227
```
228
229
[Pattern Recognition](./pattern-recognition.md)
230
231
### Signal Processing and Waveforms
232
233
Standard waveform functions and signal processing utilities for mathematical modeling and engineering applications.
234
235
```python { .api }
236
def squarew(t, period=1): ...
237
def trianglew(t, period=1): ...
238
def sawtoothw(t, period=1): ...
239
def sigmoid(x): ...
240
```
241
242
[Signal Processing](./signal-processing.md)
243
244
## Types
245
246
### Core Types
247
248
```python { .api }
249
class mpf:
250
"""
251
Multiprecision floating-point number.
252
253
Args:
254
x: Number to convert (int, float, str, or another mpf)
255
"""
256
def __init__(self, x): ...
257
def __str__(self) -> str: ...
258
def __repr__(self) -> str: ...
259
260
class mpc:
261
"""
262
Multiprecision complex number.
263
264
Args:
265
real: Real part (number or string)
266
imag: Imaginary part (number or string), default 0
267
"""
268
def __init__(self, real, imag=0): ...
269
def __str__(self) -> str: ...
270
def __repr__(self) -> str: ...
271
272
class matrix:
273
"""
274
Matrix supporting arbitrary precision arithmetic.
275
276
Args:
277
*args: Matrix dimensions or initial data
278
"""
279
def __init__(self, *args): ...
280
def __getitem__(self, key): ...
281
def __setitem__(self, key, value): ...
282
```
283
284
### Context Types
285
286
```python { .api }
287
class MPContext:
288
"""Multiprecision arithmetic context."""
289
dps: int # Decimal precision
290
prec: int # Binary precision
291
pretty: bool # Pretty printing mode
292
293
def workprec(self, n): ...
294
def workdps(self, n): ...
295
def extraprec(self, n): ...
296
297
class FPContext:
298
"""Fast double-precision floating-point context."""
299
pass
300
301
class MPIntervalContext:
302
"""Interval arithmetic context."""
303
pass
304
```