Hướng dẫn what is integrate quad in python? - Tích hợp quad trong python là gì?

scipy.integrate.quad (func, a, b, args = (), full_output = 0, epsabs = 1.49e-08, epsrel = 1.49e-08, giới hạn = 50, điểm = không, trọng lượng = không, wvar = không , wopts = none, maxp1 = 50, limlst = 50) [nguồn]#quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)[source]#

Tính toán một tích phân xác định.

Tích hợp func từ A đến B (có thể là khoảng thời gian vô hạn) bằng cách sử dụng một kỹ thuật từ quadpack thư viện Fortran.

Tham sốFunc {function, scipy.LowLevelCallable}func{function, scipy.LowLevelCallable}

Một hàm python hoặc phương pháp để tích hợp. Nếu Func có nhiều đối số, nó được tích hợp dọc theo trục tương ứng với đối số đầu tiên.

Nếu người dùng mong muốn hiệu suất tích hợp được cải thiện, thì F có thể là một scipy.LowLevelCallable với một trong những chữ ký:

double func(double x)
double func(double x, void *user_data)
double func(int n, double *xx)
double func(int n, double *xx, void *user_data)

user_data là dữ liệu có trong scipy.LowLevelCallable. Trong các biểu mẫu cuộc gọi với ____10,

>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
1 là độ dài của mảng
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
0 chứa
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
3 và phần còn lại của các mục là các số có trong đối số
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
4 của Quad.

Ngoài ra, một số chữ ký cuộc gọi CTYPES được hỗ trợ để tương thích ngược, nhưng chúng không nên được sử dụng trong mã mới.

nổifloat

Giới hạn thấp hơn của tích hợp (sử dụng -numpy.inf cho -infinity).

bfloatfloat

Giới hạn trên của tích hợp (sử dụng numpy.inf cho +vô cực).

Argstuple, tùy chọntuple, optional

Các đối số bổ sung để chuyển đến func.

full_outputint, tùy chọnint, optional

Khác không để trả về một từ điển thông tin tích hợp. Nếu không phải, các thông báo cảnh báo cũng bị triệt tiêu và tin nhắn được thêm vào phần đầu ra.

ReturnSyFloatyfloat

Tích hợp của func từ a đến b.

abserrfloatfloat

Một ước tính về lỗi tuyệt đối trong kết quả.

Infodictdictdict

Một từ điển chứa thông tin bổ sung.

thông điệp

Một thông điệp hội tụ.

giải thích

Chỉ được thêm vào với các giới hạn tích hợp và tính năng tích hợp vô hạn, nó chứa một lời giải thích về các mã trong Infodict [‘ierlst,]

Các tham số khác epsabsfloat hoặc int, tùy chọnepsabsfloat or int, optional

Dung sai lỗi tuyệt đối. Mặc định là 1.49e-8.

>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
5 cố gắng đạt được độ chính xác của
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
6 trong đó
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
7 = tích phân của func từ A đến B và
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
8 là xấp xỉ bằng số. Xem EPSREL bên dưới.

epsrelfloat hoặc int, tùy chọnfloat or int, optional

Dung sai lỗi tương đối. Mặc định là 1.49e-8. Nếu

>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
9, EPSREL phải lớn hơn cả 5E-29 và
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
0. Xem epsab ở trên.

giới hạn hoặc int, tùy chọnfloat or int, optional

Một giới hạn trên về số lượng các phân nhóm được sử dụng trong thuật toán thích ứng.

điểm (chuỗi phao, int), tùy chọn(sequence of floats,ints), optional

Một chuỗi các điểm ngắt trong khoảng thời gian tích hợp giới hạn trong đó những khó khăn cục bộ của tích phân có thể xảy ra (ví dụ: điểm kỳ dị, không liên tục). Trình tự không phải được sắp xếp. Lưu ý rằng tùy chọn này không thể được sử dụng cùng với

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
1.

tạ lại hoặc int, tùy chọnfloat or int, optional

Chuỗi biểu thị chức năng trọng số. Giải thích đầy đủ cho điều này và các đối số còn lại có thể được tìm thấy dưới đây.

Wvaroptionaloptional

Biến để sử dụng với các chức năng trọng số.

Woptsoptionaloptional

Đầu vào tùy chọn để tái sử dụng những khoảnh khắc Chebyshev.

MAXP1FLOAT hoặc INT, tùy chọnfloat or int, optional

Một giới hạn trên về số khoảnh khắc Chebyshev.

Limlstint, tùy chọnint, optional

Giới hạn trên về số lượng chu kỳ (> = 3) để sử dụng với trọng số hình sin và điểm cuối vô hạn.

Ghi chú

Thông tin bổ sung cho đầu vào và đầu ra Quad ()

Nếu full_output là khác không, thì đối số đầu ra thứ ba (infodict) là một từ điển với các mục như được lập bảng dưới đây. Đối với các giới hạn vô hạn, phạm vi được chuyển đổi thành (0,1) và các đầu ra tùy chọn được đưa ra đối với phạm vi biến đổi này. Đặt m là giới hạn đối số đầu vào và để k là vô hạn [’cuối cùng]. Các mục là:

Neval

Số lượng đánh giá chức năng.

'Cuối cùng'

Số, K, của các ô tô được tạo ra trong quá trình phân khu.

'một danh sách'

Một mảng xếp hạng 1 có độ dài m, các phần tử K đầu tiên trong đó là các điểm cuối bên trái của các phân chia trong phân vùng của phạm vi tích hợp.

’Blist

Một mảng xếp hạng 1 có độ dài m, các phần tử K đầu tiên trong đó là các điểm cuối bên phải của các ô tô.

Rlist

Một mảng xếp hạng 1 có độ dài m, các phần tử K đầu tiên trong đó là các xấp xỉ tích phân trên các phân nhóm.

Elist elist

Một mảng xếp hạng 1 có độ dài m, các phần tử K đầu tiên trong đó là mô đun của các ước tính lỗi tuyệt đối trên các phân nhóm.

Iord

Một mảng số nguyên xếp hạng 1 có độ dài m, các phần tử L đầu tiên trong đó là con trỏ ước tính lỗi so với các phân nhóm với

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
2 nếu
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
3 hoặc
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
4 khác. Hãy để tôi là chuỗi
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
5 và để e là chuỗi
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
6. Sau đó
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
7 tạo thành một chuỗi giảm.

Nếu các điểm đối số đầu vào được cung cấp (nghĩa là, nó không phải là không có), các đầu ra bổ sung sau được đặt trong từ điển đầu ra. Giả sử chuỗi điểm có độ dài P.

Pts pts

Một mảng xếp hạng 1 có độ dài P+2 chứa các giới hạn tích hợp và các điểm ngắt của các khoảng theo thứ tự tăng dần. Đây là một mảng cung cấp cho các phân nhóm mà tích hợp sẽ xảy ra.

'mức độ'

Một mảng số nguyên xếp hạng 1 có độ dài m (= giới hạn), chứa các mức phân khu của các phân nhóm, tức là, nếu (aa, bb) là một phần phụ của

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
8 trong đó
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
9 và
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
0 là các yếu tố liền kề của
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
1 ) có cấp L nếu
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
2.

Ndin

Một mảng số nguyên xếp hạng 1 có độ dài p+2. Sau khi tích hợp đầu tiên trong các khoảng thời gian (PTS [1], PTS [2]), các ước tính lỗi trong một số khoảng có thể đã được tăng lên một cách giả tạo để đưa phân khu của chúng về phía trước. Mảng này có những cái trong các khe tương ứng với các phân nhóm mà điều này xảy ra.

Trọng số tích phân

Các biến đầu vào, Trọng lượng và WVAR, được sử dụng để cân nặng trong danh sách các chức năng chọn lọc. Các phương pháp tích hợp khác nhau được sử dụng để tính toán tích phân với các chức năng trọng số này và chúng không hỗ trợ chỉ định điểm ngắt. Các giá trị có thể của trọng lượng và các hàm trọng số tương ứng là.

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
1

Chức năng trọng lượng được sử dụng

>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
4

‘Cos…

cos(w*x)

wvar = w

'tội'

sin(w*x)

wvar = w

'tội'

’Alg

g (x) = ((x-a) ** alpha)*((b-x) ** beta)

wvar = (alpha, beta)

g(x)*log(x-a)

g (x) = ((x-a) ** alpha)*((b-x) ** beta)

wvar = (alpha, beta)

g(x)*log(b-x)

g (x) = ((x-a) ** alpha)*((b-x) ** beta)

wvar = (alpha, beta)

g(x)*log(x-a)*log(b-x)

g (x) = ((x-a) ** alpha)*((b-x) ** beta)

wvar = (alpha, beta)

1/(x-c)

ALG-LOGA

ALG-LOGB,

ALG-LOG

Cauchy

wvar = c

WVAR giữ tham số W, (alpha, beta) hoặc c tùy thuộc vào trọng lượng được chọn. Trong các biểu thức này, A và B là giới hạn tích hợp.

Đối với trọng số ‘cos và‘ sin, đầu vào và đầu ra bổ sung có sẵn.

Đối với các giới hạn tích hợp hữu hạn, việc tích hợp được thực hiện bằng phương pháp clenshaw-curtis sử dụng các khoảnh khắc Chebyshev. Đối với các tính toán lặp đi lặp lại, những khoảnh khắc này được lưu trong từ điển đầu ra:

Momcom

Mức độ tối đa của những khoảnh khắc Chebyshev đã được tính toán, tức là, nếu

>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
5 là
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
6 thì các khoảnh khắc đã được tính toán cho các khoảng thời gian dài
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
7,
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
8.

Nnlog

Một mảng số nguyên xếp hạng 1 có độ dài m (= giới hạn), chứa các mức phân khu của các phân nhóm, tức là, một phần tử của mảng này bằng L nếu phần con tương ứng là
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
9.

Chebmo

Một mảng xếp hạng 2 của hình dạng (25, MAXP1) chứa những khoảnh khắc Chebyshev được tính toán. Chúng có thể được truyền lại cho một sự tích hợp trong cùng một khoảng bằng cách chuyển mảng này như phần tử thứ hai của chuỗi WOPT và chuyển qua infodict [‘momcom,] là phần tử đầu tiên.

Nếu một trong các giới hạn tích hợp là vô hạn, thì tích phân Fourier được tính toán (giả sử W NEQ 0). Nếu full_output là 1 và gặp lỗi số, bên cạnh thông báo lỗi được đính kèm với tuple đầu ra, một từ điển cũng được thêm vào bộ tuple đầu ra dịch mã lỗi trong mảng

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
0 sang các tin nhắn tiếng Anh. Từ điển thông tin đầu ra chứa các mục sau đây thay vì ‘cuối cùng,‘ Alist, ‘Blist,‘ RList, và ‘Elist,:

‘LST

Số lượng các phân nhóm cần thiết cho tích hợp (gọi nó là

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
1).

RSLST

Một mảng xếp hạng-1 có độ dài m_f = Limlst, có các yếu tố

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
1 đầu tiên chứa sự đóng góp tích phân trong khoảng thời gian
testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
3 trong đó
testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
4 và
testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
5.

Erlst

Một mảng xếp hạng 1 có độ dài

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
6 chứa ước tính lỗi tương ứng với khoảng trong cùng một vị trí trong
testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
7.

Tôi

Một mảng số nguyên xếp hạng 1 có độ dài

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
6 chứa cờ lỗi tương ứng với khoảng trong cùng một vị trí trong
testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
7. Xem từ điển giải thích (mục nhập cuối cùng trong bộ tuple đầu ra) về ý nghĩa của mã.

Chi tiết về các thói quen cấp quadpack

>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333
5 gọi các thói quen từ thư viện Fortran QuadPack. Phần này cung cấp chi tiết về các điều kiện cho mỗi thói quen được gọi và một mô tả ngắn về từng thói quen. Các thói quen gọi là phụ thuộc vào trọng lượng, điểm và tích hợp giới hạn a và b.

Thói quen QuadPack

trọng lượng

điểm

điểm

giới hạn vô hạn

trọng lượng

điểm

giới hạn vô hạn

Qagse

trọng lượng

giới hạn vô hạn

điểm

giới hạn vô hạn

Qagse

điểm

điểm

giới hạn vô hạn

Qagse

điểm

giới hạn vô hạn

Qagse

Không có

điểm

điểm

giới hạn vô hạn

wvar = (alpha, beta)

điểm

điểm

giới hạn vô hạn

Thói quen QuadPack

trọng lượng

giới hạn vô hạn

Qagse

Qagse

Không có

QAWOE

là một bộ tích hợp để đánh giá \ (\ int^b_a \ cos (\ omga x) f (x) dx \) hoặc \ (\ int^b_a \ sin (\ omega x) f (x) dx \) Khoảng thời gian hữu hạn [a, b], trong đó \ (\ omega \) và \ (f \) được chỉ định bởi người dùng. Thành phần đánh giá quy tắc dựa trên kỹ thuật clenshaw-curtis đã sửa đổi\(\int^b_a \cos(\omega x)f(x)dx\) or \(\int^b_a \sin(\omega x)f(x)dx\) over a finite interval [a,b], where \(\omega\) and \(f\) are specified by the user. The rule evaluation component is based on the modified Clenshaw-Curtis technique

Một sơ đồ phân khu thích ứng được sử dụng liên quan đến quy trình ngoại suy, là một sửa đổi của điều đó trong

from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333
1 và cho phép thuật toán xử lý các điểm kỳ dị trong \ (f (x) \).\(f(x)\).

QAWFE

Tính toán biến đổi Fourier \ (\ int^\ infty_a \ cos (\ omga x) f (x) dx \) hoặc \ (\ int^\ infty_a \ sin (\ omga x) f (x) dx \) cho người dùng- được cung cấp \ (\ omega \) và \ (f \). Quy trình của

from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333
3 được áp dụng trên các khoảng thời gian hữu hạn liên tiếp và gia tốc hội tụ bằng các phương tiện của \ (\ varepsilon \)-Thuật toán được áp dụng cho loạt các xấp xỉ tích phân.\(\int^\infty_a \cos(\omega x)f(x)dx\) or \(\int^\infty_a \sin(\omega x)f(x)dx\) for user-provided \(\omega\) and \(f\). The procedure of
from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333
3 is applied on successive finite intervals, and convergence acceleration by means of the \(\varepsilon\)-algorithm is applied to the series of integral approximations.

QAWSE

approximate \(\int^b_a w(x)f(x)dx\), with \(a < b\) where \(w(x) = (x-a)^{\alpha}(b-x)^{\beta}v(x)\) with \(\alpha,\beta > -1\), where \(v(x)\) may be one of the following functions: \(1\), \(\log(x-a)\), \(\log(b-x)\), \(\log(x-a)\log(b-x)\).

Người dùng chỉ định \ (\ alpha \), \ (\ beta \) và loại hàm \ (v \). Một chiến lược phân khu thích ứng toàn cầu được áp dụng, với tích hợp clenshaw-curtis đã sửa đổi trên các ô con có chứa a hoặc b.\(\alpha\), \(\beta\) and the type of the function \(v\). A globally adaptive subdivision strategy is applied, with modified Clenshaw-Curtis integration on those subintervals which contain a or b.

QAWCE

Tính toán \ (\ int^b_a f (x) / (x-c) dx \) trong đó tích phân phải được hiểu là tích phân giá trị chính của Cauchy, đối với người dùng được chỉ định \ (c \) và \ (f \). Chiến lược là thích ứng trên toàn cầu. Tích hợp clenshaw-curtis sửa đổi được sử dụng trên các khoảng đó chứa điểm \ (x = c \).\(\int^b_a f(x) / (x-c)dx\) where the integral must be interpreted as a Cauchy principal value integral, for user specified \(c\) and \(f\). The strategy is globally adaptive. Modified Clenshaw-Curtis integration is used on those intervals containing the point \(x = c\).

Người giới thiệu

1

Piessens, Robert; De Doncker-Kapenga, Elise; Überhuber, Christoph W .; Kahaner, David (1983). QuadPack: Gói chương trình con để tích hợp tự động. Springer-Verlag. ISBN 980-3-540-12553-2.

Ví dụ

Tính toán \ (\ int^4_0 x^2 dx \) và so sánh với kết quả phân tích\(\int^4_0 x^2 dx\) and compare with an analytic result

>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333

Tính toán \ (\ int^\ infty_0 e^{-x} dx \)\(\int^\infty_0 e^{-x} dx\)

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)

Tính toán \ (\ int^1_0 a x \, dx \) cho \ (a = 1, 3 \)\(\int^1_0 a x \,dx\) for \(a = 1, 3\)

>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5

Tính toán \ (\ int^1_0 x^2 + y^2 dx \) với ctypes, giữ tham số y là 1:\(\int^1_0 x^2 + y^2 dx\) with ctypes, holding y parameter as 1:

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*

from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333

Xin lưu ý rằng các hình dạng xung và các tính năng sắc nét khác so với kích thước của khoảng thời gian tích hợp có thể không được tích hợp chính xác bằng phương pháp này. Một ví dụ đơn giản hóa về giới hạn này là tích hợp hàm bước phản xạ trục y với nhiều giá trị bằng không trong giới hạn tích phân.

>>> y = lambda x: 1 if x<=0 else 0
>>> integrate.quad(y, -1, 1)
(1.0, 1.1102230246251565e-14)
>>> integrate.quad(y, -1, 100)
(1.0000000002199108, 1.0189464580163188e-08)
>>> integrate.quad(y, -1, 10000)
(0.0, 0.0)

Tích hợp trong Python là gì?

Tích hợp số Python khoa học cung cấp một số thói quen tích hợp.Một công cụ mục đích chung để giải quyết các tích phân I của loại.I = ∫baf (x) dx.được cung cấp bởi hàm Quad () của mô -đun scipy.integrate.A general purpose tool to solve integrals I of the kind. I=∫baf(x)dx. is provided by the quad() function of the scipy. integrate module.

Scipy Quad sử dụng phương pháp nào?

Quad sử dụng "một kỹ thuật từ thư viện Fortran QuadPack".Quadpack cung cấp một số thói quen bằng cách sử dụng các kỹ thuật khác nhau.a technique from the Fortran library QUADPACK". QUADPACK provides several routines using different techniques.

Làm thế nào để bạn tích hợp với Scipy?

Nhiều tích phân..
Nhập Scipy.tích hợp..
từ exp nhập khẩu numpy ..
từ nhập khẩu toán học sqrt ..
F = Lambda X, Y: 16*X*Y ..
g = lambda x: 0 ..
h = lambda y: Sqrt (1-4*y ** 2).
i = scipy.tích hợp.Dblquad (F, 0, 0,5, g, h).
print(i).