SciPy 0.11.0参考指南：科学计算库详解

需积分: 9 95 浏览量更新于2024-07-17 收藏 5.81MB PDF 举报

"SciPy是Python生态系统中的一个开源库，专注于科学计算，提供了一系列高级算法和数学函数。这个参考指南详细介绍了SciPy的不同模块和功能，涵盖了从基础的数值操作到复杂的科学计算任务。" 在Python的科学计算领域，SciPy扮演着至关重要的角色。它建立在Numpy之上，提供了许多高级数学、统计和工程计算工具。以下是对SciPy中各个模块的简要概述： 1. **SciPy Tutorial**：这部分为初学者提供了入门指导，讲解了如何使用SciPy进行科学计算。 1.1 **Introduction**：介绍SciPy的基本概念和安装方法，以及它在Python科学计算环境中的位置。 1.2 **Basic functions in Numpy (and top-level scipy)**：讲解了Numpy的基础操作，包括数组创建、算术运算以及数据处理，同时也介绍了SciPy顶层的一些功能。 1.3 **Special functions (scipy.special)**：包含了各种特殊函数，如伽马函数、贝塞尔函数等，这些在物理、工程和统计学中有广泛应用。 1.4 **Integration (scipy.integrate)**：提供了数值积分的方法，包括单变量和多变量积分，以及常微分方程的求解。 1.5 **Optimization (scipy.optimize)**：包含求解最小化问题、拟合、插值、线性规划等优化算法。 1.6 **Interpolation (scipy.interpolate)**：提供了不同类型的插值方法，用于创建平滑曲线或表面来近似离散数据。 1.7 **Fourier Transforms (scipy.fftpack)**：实现了快速傅里叶变换（FFT）及相关函数，用于信号分析和图像处理。 1.8 **Signal Processing (scipy.signal)**：包含信号处理工具，如滤波器设计、频谱分析、窗口函数等。 1.9 **Linear Algebra (scipy.linalg)**：提供了线性代数运算，如矩阵运算、特征值问题、奇异值分解等。 1.10 **Sparse Eigenvalue Problems with ARPACK**：ARPACK是一个用于求解大型稀疏矩阵特征值问题的库，SciPy提供了接口。 1.11 **Statistics (scipy.stats)**：涵盖统计分析，包括概率分布、假设检验、回归分析等。 1.12 **Multi-dimensional image processing (scipy.ndimage)**：提供了多维图像处理的功能，如图像滤波、形态学操作和测量。 1.13 **File I/O (scipy.io)**：支持多种科学数据格式的读写，如MATLAB文件、wav音频文件等。 1.14 **Weave (scipy.weave)**：允许将C/C++代码直接集成到Python脚本中，提高性能。 2. **API-importing from SciPy**：这部分指导用户如何正确地导入和使用SciPy中的函数，遵循一定的导入规范。 3. **Release Notes**：记录了各版本的更新和改进，帮助用户了解新功能和修复的问题。以上内容构成了SciPy参考指南的主要框架，为用户提供了全面的使用指南和API文档，是进行科学计算不可或缺的资源。通过学习和应用这些模块，开发者可以高效地解决各种科学和工程问题。

SciPy Reference Guide, Release 0.11.0.dev-600e81f

1.4.1 General integration (quad)

The function quad is provided to integrate a function of one variable between two points. The points can be ±∞ (±

inf) to indicate inﬁnite limits. For example, suppose you wish to integrate a bessel function jv(2.5,x) along the

interval [0, 4.5].

I =

4.5

2.5

(x) dx.

This could be computed using quad:

>>> result = integrate.quad(lambda x: special.jv(2.5,x), 0, 4.5)

>>> print result

(1.1178179380783249, 7.8663172481899801e-09)

>>> I = sqrt(2/pi)

(18.0/27

sqrt(2)

cos(4.5)-4.0/27

sqrt(2)

sin(4.5)+

sqrt(2

pi)

special.fresnel(3/sqrt(pi))[0])

>>> print I

1.117817938088701

>>> print abs(result[0]-I)

1.03761443881e-11

The ﬁrst argument to quad is a “callable” Python object (i.e a function, method, or class instance). Notice the use of a

lambda- function in this case as the argument. The next two arguments are the limits of integration. The return value

is a tuple, with the ﬁrst element holding the estimated value of the integral and the second element holding an upper

bound on the error. Notice, that in this case, the true value of this integral is

I =



√

2 cos (4.5) −

√

2 sin (4.5) +

√

2πSi



√



where

Si (x) =

sin





dt.

is the Fresnel sine integral. Note that the numerically-computed integral is within 1.04 × 10

−11

of the exact result —

well below the reported error bound.

Inﬁnite inputs are also allowed in quad by using ± inf as one of the arguments. For example, suppose that a

numerical value for the exponential integral:

(x) =

∞

−xt

dt.

is desired (and the fact that this integral can be computed as special.expn(n,x) is forgotten). The functionality

of the function special.expn can be replicated by deﬁning a new function vec_expint based on the routine

quad:

>>> from scipy.integrate import quad

>>> def integrand(t,n,x):

... return exp(-x

t) / t

>>> def expint(n,x):

... return quad(integrand, 1, Inf, args=(n, x))[0]

>>> vec_expint = vectorize(expint)

>>> vec_expint(3,arange(1.0,4.0,0.5))

array([ 0.1097, 0.0567, 0.0301, 0.0163, 0.0089, 0.0049])

>>> special.expn(3,arange(1.0,4.0,0.5))

array([ 0.1097, 0.0567, 0.0301, 0.0163, 0.0089, 0.0049])

12 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.11.0.dev-600e81f

The function which is integrated can even use the quad argument (though the error bound may underestimate the error

due to possible numerical error in the integrand from the use of quad ). The integral in this case is

∞

−xt

dt dx =

>>> result = quad(lambda x: expint(3, x), 0, inf)

>>> print result

(0.33333333324560266, 2.8548934485373678e-09)

>>> I3 = 1.0/3.0

>>> print I3

0.333333333333

>>> print I3 - result[0]

8.77306560731e-11

This last example shows that multiple integration can be handled using repeated calls to quad. The mechanics of this

for double and triple integration have been wrapped up into the functions

dblquad and tplquad. The function,

dblquad performs double integration. Use the help function to be sure that the arguments are deﬁned in the correct

order. In addition, the limits on all inner integrals are actually functions which can be constant functions. An example

of using double integration to compute several values of I

is shown below:

>>> from scipy.integrate import quad, dblquad

>>> def I(n):

... return dblquad(lambda t, x: exp(-x

t)/t

n, 0, Inf, lambda x: 1, lambda x: Inf)

>>> print I(4)

(0.25000000000435768, 1.0518245707751597e-09)

>>> print I(3)

(0.33333333325010883, 2.8604069919261191e-09)

>>> print I(2)

(0.49999999999857514, 1.8855523253868967e-09)

1.4.2 Gaussian quadrature (integrate.gauss_quadtol)

A few functions are also provided in order to perform simple Gaussian quadrature over a ﬁxed interval. The ﬁrst

is fixed_quad which performs ﬁxed-order Gaussian quadrature. The second function is quadrature which

performs Gaussian quadrature of multiple orders until the difference in the integral estimate is beneath some tolerance

supplied by the user. These functions both use the module special.orthogonal which can calculate the roots

and quadrature weights of a large variety of orthogonal polynomials (the polynomials themselves are available as

special functions returning instances of the polynomial class — e.g. special.legendre).

1.4.3 Integrating using samples

There are three functions for computing integrals given only samples: trapz , simps, and romb . The ﬁrst two

functions use Newton-Coates formulas of order 1 and 2 respectively to perform integration. These two functions

can handle, non-equally-spaced samples. The trapezoidal rule approximates the function as a straight line between

adjacent points, while Simpson’s rule approximates the function between three adjacent points as a parabola.

If the samples are equally-spaced and the number of samples available is 2

+ 1 for some integer k, then Romberg

integration can be used to obtain high-precision estimates of the integral using the available samples. Romberg in-

tegration uses the trapezoid rule at step-sizes related by a power of two and then performs Richardson extrapolation

on these estimates to approximate the integral with a higher-degree of accuracy. (A different interface to Romberg

integration useful when the function can be provided is also available as romberg).

1.4. Integration (scipy.integrate) 13

SciPy Reference Guide, Release 0.11.0.dev-600e81f

1.4.4 Ordinary differential equations (odeint)

Integrating a set of ordinary differential equations (ODEs) given initial conditions is another useful example. The

function odeint is available in SciPy for integrating a ﬁrst-order vector differential equation:

= f (y, t) ,

given initial conditions y (0) = y

, where y is a length N vector and f is a mapping from R

to R

. A higher-order

ordinary differential equation can always be reduced to a differential equation of this type by introducing intermediate

derivatives into the y vector.

For example suppose it is desired to ﬁnd the solution to the following second-order differential equation:

− zw(z) = 0

with initial conditions w (0) =

√

(

)

and



z=0

= −

√

3Γ

(

)

. It is known that the solution to this differential

equation with these boundary conditions is the Airy function

w = Ai (z) ,

which gives a means to check the integrator using

special.airy.

First, convert this ODE into standard form by setting y =



, w



and t = z. Thus, the differential equation becomes







0 t

1 0







0 t

1 0



In other words,

f (y, t) = A (t) y.

As an interesting reminder, if A (t) commutes with

A (τ) dτ under matrix multiplication, then this linear differen-

tial equation has an exact solution using the matrix exponential:

y (t) = e xp



A (τ) dτ



y (0) ,

However, in this case, A (t) and its integral do not commute.

There are many optional inputs and outputs available when using odeint which can help tune the solver. These ad-

ditional inputs and outputs are not needed much of the time, however, and the three required input arguments and

the output solution sufﬁce. The required inputs are the function deﬁning the derivative, fprime, the initial conditions

vector, y0, and the time points to obtain a solution, t, (with the initial value point as the ﬁrst element of this sequence).

The output to odeint is a matrix where each row contains the solution vector at each requested time point (thus, the

initial conditions are given in the ﬁrst output row).

The following example illustrates the use of odeint including the usage of the Dfun option which allows the user to

specify a gradient (with respect to y ) of the function, f (y, t).

>>> from scipy.integrate import odeint

>>> from scipy.special import gamma, airy

>>> y1_0 = 1.0/3

(2.0/3.0)/gamma(2.0/3.0)

>>> y0_0 = -1.0/3

(1.0/3.0)/gamma(1.0/3.0)

>>> y0 = [y0_0, y1_0]

>>> def func(y, t):

... return [t

y[1],y[0]]

14 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.11.0.dev-600e81f

>>> from scipy.optimize import fmin

>>> def rosen(x):

... """The Rosenbrock function"""

... return sum(100.0

(x[1:]-x[:-1]

2.0)

2.0 + (1-x[:-1])

2.0)

>>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]

>>> xopt = fmin(rosen, x0, xtol=1e-8)

Optimization terminated successfully.

Current function value: 0.000000

Iterations: 339

Function evaluations: 571

>>> print xopt

[ 1. 1. 1. 1. 1.]

Another optimization algorithm that needs only function calls to ﬁnd the minimum is Powell’s method available as

fmin_powell.

1.5.2 Broyden-Fletcher-Goldfarb-Shanno algorithm (fmin_bfgs)

In order to converge more quickly to the solution, this routine uses the gradient of the objective function. If the gradient

is not given by the user, then it is estimated using ﬁrst-differences. The Broyden-Fletcher-Goldfarb-Shanno (BFGS)

method typically requires fewer function calls than the simplex algorithm even when the gradient must be estimated.

To demonstrate this algorithm, the Rosenbrock function is again used. The gradient of the Rosenbrock function is the

vector:

∂f

∂x

i=1

200



− x

i−1



(δ

i,j

− 2x

i−1

i−1,j

) − 2 (1 − x

i−1

) δ

i−1,j

= 200



− x

j−1



− 400x



j+1

− x



− 2 (1 − x

) .

This expression is valid for the interior derivatives. Special cases are

∂f

∂x

= −400x



− x



− 2 (1 − x

) ,

∂f

∂x

N−1

= 200



N−1

− x

N−2



A Python function which computes this gradient is constructed by the code-segment:

>>> def rosen_der(x):

... xm = x[1:-1]

... xm_m1 = x[:-2]

... xm_p1 = x[2:]

... der = zeros_like(x)

... der[1:-1] = 200

(xm-xm_m1

2) - 400

(xm_p1 - xm

xm - 2

(1-xm)

... der[0] = -400

x[0]

(x[1]-x[0]

2) - 2

(1-x[0])

... der[-1] = 200

(x[-1]-x[-2]

... return der

The calling signature for the BFGS minimization algorithm is similar to fmin with the addition of the fprime ar-

gument. An example usage of fmin_bfgs is shown in the following example which minimizes the Rosenbrock

function.

>>> from scipy.optimize import fmin_bfgs

16 Chapter 1. SciPy Tutorial

剩余982页未读，继续阅读

chunyangsuhao

粉丝: 103
资源: 7382

SciPy 0.11.0参考指南：科学计算库详解

scipy和numpy参考手册 pdf

SciPy Reference Guide Release 0.13.0.pdf

SciPy_Reference_Guide

scipy-ref-1.7.1.pdf

SciPy 1.7.1 Reference Guide

sympy-docs-pdf-1.0.pdf

numpy-ref-1.11.0.pdf

scipy-ref-1.0.0

SciPy 0.11.0 数据处理扩展全指南：Python中的MATLAB替代

用Python做科学计算.pdf

最新资源