SymPy - Hướng dẫn nhanh
SymPy là một thư viện Python để thực hiện tính toán tượng trưng. Nó là mộtcomputer algebra system(CAS) có thể được sử dụng như một ứng dụng độc lập, làm thư viện cho các ứng dụng khác. Phiên trực tiếp của nó cũng có sẵn tạihttps://live.sympy.org/. Vì nó là một thư viện Python thuần túy, nó có thể được sử dụng như một chế độ tương tác và như một ứng dụng lập trình. SymPy hiện đã trở thành một thư viện biểu tượng phổ biến cho hệ sinh thái Python khoa học.
SymPy có một loạt các tính năng áp dụng trong lĩnh vực số học biểu tượng cơ bản, giải tích, đại số, toán học rời rạc, vật lý lượng tử, v.v. SymPy có khả năng định dạng kết quả theo nhiều định dạng bao gồm LaTeX, MathML, v.v. SymPy được phân phối theo Giấy phép BSD mới. Một nhóm các nhà phát triển doOndřej Čertík và Aaron Meurer xuất bản phiên bản đầu tiên của SymPy vào năm 2007. Phiên bản hiện tại của nó là 1.5.1.
Một số lĩnh vực ứng dụng của SymPy là:
- Polynomials
- Calculus
- Toán học rời rạc
- Matrices
- Geometry
- Plotting
- Physics
- Statistics
- Combinatorics
SymPy có một thư viện điều kiện tiên quyết quan trọng có tên mpmath. Nó là một thư viện Python dành cho số học dấu phẩy động thực và phức tạp với độ chính xác tùy ý. Tuy nhiên, trình cài đặt gói PIP của Python sẽ tự động cài đặt nó khi SymPy được cài đặt như sau:
pip install sympyCác bản phân phối Python khác như Anaconda, Enthought Canopy, v.v., có thể có SymPy đã được đóng gói sẵn trong đó. Để xác minh, bạn có thể nhập nội dung sau vào lời nhắc Python:
>>> import sympy
>>> sympy.__version__Và bạn nhận được kết quả bên dưới là phiên bản hiện tại của giao hưởng -
'1.5.1'
Mã nguồn của gói SymPy hiện có tại https://github.com/sympy/sympy.
Tính toán biểu tượng đề cập đến việc phát triển các thuật toán để thao tác các biểu thức toán học và các đối tượng toán học khác. Tính toán biểu tượng tích hợp toán học với khoa học máy tính để giải quyết các biểu thức toán học bằng cách sử dụng các ký hiệu toán học. Một Hệ thống Đại số Máy tính (CAS) như SymPy đánh giá các biểu thức đại số chính xác (không gần đúng) bằng cách sử dụng các ký hiệu tương tự được sử dụng trong phương pháp thủ công truyền thống. Ví dụ: chúng tôi tính căn bậc hai của một số bằng mô-đun toán học của Python như được đưa ra bên dưới:
>>> import math
>>> print (math.sqrt(25), math.sqrt(7))Đầu ra cho đoạn mã trên như sau:
5.0 2.6457513110645907
Như bạn thấy, căn bậc hai của 7 được tính gần đúng. Nhưng trong SymPy căn bậc hai của các số không phải là bình phương hoàn hảo được để mặc định không được đánh giá như cho dưới đây:
>>> import sympy
>>> print (sympy.sqrt(7))Đầu ra cho đoạn mã trên như sau:
sqrt(7)
Có thể đơn giản hóa và hiển thị kết quả của biểu thức một cách tượng trưng bằng đoạn mã bên dưới:
>>> import math
>>> print (math.sqrt(12))Đầu ra cho đoạn mã trên như sau:
3.4641016151377544
Bạn cần sử dụng đoạn mã dưới đây để thực thi tương tự bằng cách sử dụng giao hưởng -
##sympy output
>>> print (sympy.sqrt(12))Và đầu ra cho điều đó như sau:
2*sqrt(3)
Mã SymPy, khi chạy trong sổ ghi chép Jupyter, sử dụng thư viện MathJax để hiển thị các ký hiệu toán học ở dạng LatEx. Nó được hiển thị trong đoạn mã dưới đây -
>>> from sympy import *
>>> x=Symbol ('x')
>>> expr = integrate(x**x, x)
>>> exprKhi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
Integral(x**x, x)Tương đương với
$\int \mathrm{x}^{x}\,\mathrm{d}x$
Căn bậc hai của một hình vuông không hoàn hảo có thể được biểu diễn bằng Latex như sau bằng cách sử dụng ký hiệu truyền thống:
>>> from sympy import *
>>> x=7
>>> sqrt(x)Đầu ra cho đoạn mã trên như sau:
$\sqrt7$
Một hệ thống tính toán tượng trưng như SymPy thực hiện tất cả các loại tính toán (chẳng hạn như đạo hàm, tích phân và giới hạn, giải phương trình, làm việc với ma trận) một cách tượng trưng. Gói SymPy có các mô-đun khác nhau hỗ trợ vẽ, in (như LATEX), vật lý, thống kê, tổ hợp, lý thuyết số, hình học, logic, v.v.
Mô-đun cốt lõi trong gói SymPy chứa lớp Số đại diện cho các số nguyên tử. Lớp này có hai lớp con: lớp Float và lớp Rational. Lớp Rational được mở rộng thêm bởi lớp Integer.
Lớp Float đại diện cho một số dấu phẩy động có độ chính xác tùy ý.
>>> from sympy import Float
>>> Float(6.32)Đầu ra cho đoạn mã trên như sau:
6.32
SymPy có thể chuyển đổi một số nguyên hoặc một chuỗi thành float.
>>> Float(10)10.0
Float('1.33E5')# scientific notation133000.0
Trong khi chuyển đổi thành float, cũng có thể chỉ định số chữ số cho độ chính xác như được đưa ra bên dưới:
>>> Float(1.33333,2)Đầu ra cho đoạn mã trên như sau:
1.3
Biểu diễn một số (p / q) được biểu diễn dưới dạng đối tượng của lớp Rational với q là một số khác 0.
>>> Rational(3/4)Đầu ra cho đoạn mã trên như sau:
$\frac{3}{4}$
Nếu một số dấu phẩy động được chuyển tới hàm tạo Rational (), nó sẽ trả về giá trị cơ bản của biểu diễn nhị phân của nó
>>> Rational(0.2)Đầu ra cho đoạn mã trên như sau:
$\frac{3602879701896397}{18014398509481984}$
Để biểu diễn đơn giản hơn, hãy chỉ định giới hạn mẫu số.
>>> Rational(0.2).limit_denominator(100)Đầu ra cho đoạn mã trên như sau:
$\frac{1}{5}$
Khi một chuỗi được chuyển tới hàm tạo Rational (), một số hữu tỉ có độ chính xác tùy ý được trả về.
>>> Rational("3.65")Đầu ra cho đoạn mã trên như sau:
$\frac{73}{20}$
Đối tượng Rational cũng có thể nhận được nếu truyền hai đối số số. Các phần tử số và mẫu số có sẵn dưới dạng thuộc tính.
>>> a=Rational(3,5)
>>> print (a)
>>> print ("numerator:{}, denominator:{}".format(a.p, a.q))Đầu ra cho đoạn mã trên như sau:
3/5
numerator:3, denominator:5
>>> aĐầu ra cho đoạn mã trên như sau:
$\frac{3}{5}$
Lớp Integer trong SymPy đại diện cho một số nguyên có kích thước bất kỳ. Hàm tạo có thể chấp nhận số Float hoặc Rational, nhưng phần phân số sẽ bị loại bỏ
>>> Integer(10)Đầu ra cho đoạn mã trên như sau:
10
>>> Integer(3.4)Đầu ra cho đoạn mã trên như sau:
3
>>> Integer(2/7)Đầu ra cho đoạn mã trên như sau:
0
SymPy có một RealNumberlớp đóng vai trò bí danh cho Float. SymPy cũng định nghĩa Zero và One là các lớp singleton có thể truy cập tương ứng với S.Zero và S.One như hình dưới đây:
>>> S.ZeroKết quả như sau:
0
>>> S.OneKết quả như sau:
1
Các đối tượng số Singleton được xác định trước khác là Half, NaN, Infinity và ImaginaryUnit
>>> from sympy import S
>>> print (S.Half)Kết quả như sau:
½
>>> print (S.NaN)Kết quả như sau:
nan
Infinity có sẵn dưới dạng đối tượng biểu tượng oo hoặc S.Infinity
>>> from sympy import oo
>>> ooĐầu ra cho đoạn mã trên như sau:
$\infty$
>>> S.InfinityĐầu ra cho đoạn mã trên như sau:
$\infty$
Số ImaginaryUnit có thể được nhập dưới dạng ký hiệu I hoặc được truy cập dưới dạng S.ImaginaryUnit và đại diện cho căn bậc hai của -1
>>> from sympy import I
>>> IKhi bạn thực thi đoạn mã trên, bạn nhận được kết quả sau:
i
>>> S.ImaginaryUnitĐầu ra của đoạn mã trên như sau:
i
>>> from sympy import sqrt
>>> i=sqrt(-1)
>>> i*iKhi bạn thực thi đoạn mã trên, bạn nhận được kết quả sau:
-1
Symbollà lớp quan trọng nhất trong thư viện symPy. Như đã đề cập trước đó, các phép tính ký hiệu được thực hiện với các ký hiệu. Biến SymPy là các đối tượng của lớp Symbols.
Đối số của hàm Symbol () là một chuỗi chứa ký hiệu có thể được gán cho một biến.
>>> from sympy import Symbol
>>> x=Symbol('x')
>>> y=Symbol('y')
>>> expr=x**2+y**2
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^2 + y^2$
Một ký hiệu có thể có nhiều hơn một bảng chữ cái.
>>> s=Symbol('side')
>>> s**3Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$side^3$
SymPy cũng có một Symbols()chức năng có thể xác định nhiều ký hiệu cùng một lúc. Chuỗi chứa tên của các biến được phân tách bằng dấu phẩy hoặc dấu cách.
>>> from sympy import symbols
>>> x,y,z=symbols("x,y,z")Trong mô-đun abc của SymPy, tất cả các bảng chữ cái Latinh và Hy Lạp được định nghĩa là ký hiệu. Do đó, thay vì khởi tạo đối tượng Symbol, phương pháp này rất tiện lợi.
>>> from sympy.abc import x,y,zTuy nhiên, những cái tên C, O, S, I, N, E và Qlà các ký hiệu được xác định trước. Ngoài ra, các biểu tượng có nhiều hơn một bảng chữ cái không được xác định trong mô-đun abc, mà bạn nên sử dụng đối tượng Symbol như trên. Mô-đun abc xác định các tên đặc biệt có thể phát hiện các định nghĩa trong không gian tên SymPy mặc định. clash1 chứa các ký tự đơn và clash2 có các ký hiệu đụng độ nhiều chữ cái
>>> from sympy.abc import _clash1, _clash2
>>> _clash1Đầu ra của đoạn mã trên như sau:
{'C': C, 'O': O, 'Q': Q, 'N': N, 'I': I, 'E': E, 'S': S}
>>> _clash2Đầu ra của đoạn mã trên như sau:
{'beta': beta, 'zeta': zeta, 'gamma': gamma, 'pi': pi}
Các ký hiệu được lập chỉ mục có thể được xác định bằng cú pháp tương tự như hàm range (). Các phạm vi được biểu thị bằng dấu hai chấm. Loại phạm vi được xác định bởi ký tự ở bên phải dấu hai chấm. Nếu nó là một chữ số, tất cả các chữ số liền kề bên trái được lấy làm giá trị bắt đầu không âm. Tất cả các chữ số liền kề ở bên phải được lấy lớn hơn giá trị cuối cùng là 1.
>>> from sympy import symbols
>>> symbols('a:5')Đầu ra của đoạn mã trên như sau:
(a0, a1, a2, a3, a4)
>>> symbols('mark(1:4)')Đầu ra của đoạn mã trên như sau:
(mark1, mark2, mark3)
Một trong những phép toán cơ bản nhất được thực hiện trên một biểu thức toán học là phép thay thế. Hàm subs () trong SymPy thay thế tất cả các lần xuất hiện của tham số đầu tiên bằng tham số thứ hai.
>>> from sympy.abc import x,a
>>> expr=sin(x)*sin(x)+cos(x)*cos(x)
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\sin^2(x)+\cos^2(x)$
>>> expr.subs(x,a)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\sin^2(a)+\cos^2(a)$
Hàm này rất hữu ích nếu chúng ta muốn đánh giá một biểu thức nào đó. Ví dụ, chúng ta muốn tính giá trị của biểu thức sau bằng cách thay a bằng 5.
>>> expr=a*a+2*a+5
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$a^2 + 2a + 5$
expr.subs(a,5)Đoạn mã trên cho kết quả sau:
40
>>> from sympy.abc import x
>>> from sympy import sin, pi
>>> expr=sin(x)
>>> expr1=expr.subs(x,pi)
>>> expr1Đoạn mã trên cho kết quả sau:
0
Hàm này cũng được sử dụng để thay thế một biểu thức con bằng một biểu thức con khác. Trong ví dụ sau, b được thay thế bằng a + b.
>>> from sympy.abc import a,b
>>> expr=(a+b)**2
>>> expr1=expr.subs(b,a+b)
>>> expr1Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$(2a + b)^2$
Hàm evalify () được sử dụng để chuyển đổi bất kỳ biểu thức tùy ý nào để nó có thể được sử dụng làm biểu thức SymPy. Các đối tượng Python bình thường như đối tượng số nguyên được chuyển đổi trong SymPy. Số nguyên, v.v., chuỗi cũng được chuyển đổi thành biểu thức SymPy.
>>> expr="x**2+3*x+2"
>>> expr1=sympify(expr)
>>> expr1
>>> expr1.subs(x,2)Đoạn mã trên cho kết quả sau:
12
Bất kỳ đối tượng Python nào cũng có thể được chuyển đổi trong đối tượng SymPy. Tuy nhiên, vì chuyển đổi bên trong sử dụng hàm eval (), không nên sử dụng biểu thức không được dọn dẹp, nếu không SympifyError sẽ xuất hiện.
>>> sympify("x***2")
---------------------------------------------------------------------------SympifyError: Sympify của biểu thức 'không thể phân tích cú pháp' x *** 2 '' không thành công, do ngoại lệ được đưa ra.
Hàm evalify () nhận các đối số sau: * nghiêm ngặt: mặc định là Sai. Nếu được đặt thành True, chỉ những loại chuyển đổi rõ ràng đã được xác định mới được chuyển đổi. Nếu không, SympifyError sẽ xuất hiện. * đánh giá: Nếu được đặt thành Sai, số học và toán tử sẽ được chuyển đổi thành tương đương SymPy của chúng mà không đánh giá biểu thức.
>>> sympify("10/5+4/2")Đoạn mã trên cho kết quả sau:
4
>>> sympify("10/5+4/2", evaluate=False)Đoạn mã trên cho kết quả sau:
$\frac{10}{5}+\frac{4}{2}$
Hàm này đánh giá một biểu thức số nhất định với độ chính xác dấu phẩy động nhất định lên đến 100 chữ số. Hàm cũng nhận tham số phụ là đối tượng từ điển của các giá trị số cho các ký hiệu. Xem xét biểu thức sau
>>> from sympy.abc import r
>>> expr=pi*r**2
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\Pi{r^2}$
Để đánh giá biểu thức trên bằng cách sử dụng hàm evalf () bằng cách thay r bằng 5
>>> expr.evalf(subs={r:5})Đoạn mã trên cho kết quả sau:
78.5398163397448
Theo mặc định, độ chính xác dấu phẩy động là tối đa 15 chữ số có thể được ghi đè bởi bất kỳ số nào lên đến 100. Biểu thức sau được đánh giá độ chính xác tối đa 20 chữ số.
>>> expr=a/b
>>> expr.evalf(20, subs={a:100, b:3})Đoạn mã trên cho kết quả sau:
33.333333333333333333
Hàm lambdify dịch các biểu thức SymPy thành các hàm Python. Nếu một biểu thức được đánh giá trên một phạm vi giá trị lớn, thì hàm evalf () không hiệu quả. lambdify hoạt động giống như một hàm lambda, ngoại trừ nó chuyển đổi tên SymPy thành tên của thư viện số đã cho, thường là NumPy. Theo mặc định, lambdify trên các triển khai trong thư viện chuẩn toán học.
>>> expr=1/sin(x)
>>> f=lambdify(x, expr)
>>> f(3.14)Đoạn mã trên cho kết quả sau:
627.8831939138764
Biểu thức có thể có nhiều hơn một biến. Trong trường hợp đó, đối số đầu tiên của hàm lambdify () là danh sách các biến, tiếp theo là biểu thức được đánh giá.
>>> expr=a**2+b**2
>>> f=lambdify([a,b],expr)
>>> f(2,3)Đoạn mã trên cho kết quả sau:
13
Tuy nhiên, để tận dụng thư viện numpy dưới dạng phụ trợ số, chúng ta phải định nghĩa giống như một đối số cho hàm lambdify ().
>>> f=lambdify([a,b],expr, "numpy")Chúng ta sử dụng hai mảng numpy cho hai đối số a và b trong hàm trên. Thời gian thực hiện nhanh đáng kể trong trường hợp các mảng không phức tạp.
>>> import numpy
>>> l1=numpy.arange(1,6)
>>> l2=numpy.arange(6,11)
>>> f(l1,l2)Đoạn mã trên cho kết quả sau:
array([ 37, 53, 73, 97, 125], dtype=int32)
Các hàm boolean được định nghĩa trong sympy.basic.booleanarg module. Có thể xây dựng biểu thức Boolean với các toán tử python tiêu chuẩn & (Và), | (Hoặc), ~ (Không) cũng như với >> và <<. Biểu thức Boolean kế thừa từ lớp Cơ bản được định nghĩa trong mô-đun cốt lõi của SymPy.
Hàm BooleanTrue
Hàm này tương đương với True như trong Python lõi. Nó trả về một singleton có thể được truy xuất bởi S.true.
>>> from sympy import *
>>> x=sympify(true)
>>> x, S.trueĐoạn mã trên cho kết quả sau:
(Đúng rồi)
Hàm BooleanFalse
Tương tự, hàm này tương đương với Boolean False trong Python và có thể được truy cập bởi S.false
>>> from sympy import *
>>> x=sympify(false)
>>> x, S.falseĐoạn mã trên cho kết quả sau:
(Sai, Sai)
Và chức năng
Một hàm AND lôgic đánh giá hai đối số của nó và trả về Sai nếu một trong hai đối số đó là Sai. Chức năng mô phỏng & điều hành.
>>> from sympy import *
>>> from sympy.logic.boolalg import And
>>> x,y=symbols('x y')
>>> x=True
>>> y=True
>>> And(x,y), x"&"yĐoạn mã trên cho kết quả sau:
(Đúng rồi)
>>> y=False
>>> And(x,y), x"&"yĐoạn mã trên cho kết quả sau:
(Sai, Sai)
Hoặc chức năng
Hàm này đánh giá hai đối số Boolean và trả về True nếu một trong hai đối số là True. Các | nhà điều hành thuận tiện mô phỏng hành vi của nó.
>>> from sympy import *
>>> from sympy.logic.boolalg import Or
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Or(x,y), x|yĐoạn mã trên cho kết quả sau:
(Đúng rồi)
>>> x=False
>>> y=False
>>> Or(x,y), x|yĐoạn mã trên cho kết quả sau:
(Sai, Sai)
Không hoạt động
Một hàm Logical Not dẫn đến việc phủ định đối số Boolean. Nó trả về True nếu đối số của nó là False và trả về False nếu True. Toán tử ~ thực hiện thao tác tương tự như hàm Not. Nó được hiển thị trong ví dụ dưới đây -
>>> from sympy import *
>>> from sympy.logic.boolalg import Or, And, Not
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Not(x), Not(y)Đoạn mã trên cho kết quả sau:
(Sai đúng)
>>> Not(And(x,y)), Not(Or(x,y))Đoạn mã trên cho kết quả sau:
(Đúng sai)
Hàm Xor
Hàm Logical XOR (độc quyền OR) trả về True nếu một số lẻ của các đối số là Đúng và phần còn lại là Sai và trả về Sai nếu một số chẵn của các đối số là Đúng và phần còn lại là Sai. Hoạt động tương tự được thực hiện bởi toán tử ^.
>>> from sympy import *
>>> from sympy.logic.boolalg import Xor
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Xor(x,y), x^yĐoạn mã trên cho kết quả sau:
(Đúng rồi)
>>> a,b,c,d,e=symbols('a b c d e')
>>> a,b,c,d,e=(True, False, True, True, False)
>>> Xor(a,b,c,d,e)Đoạn mã trên cho kết quả sau:
Thật
Trong trường hợp trên, ba đối số (số lẻ) là True, do đó Xor trả về true. Tuy nhiên, nếu số lượng đối số True là chẵn, nó dẫn đến False, như được hiển thị bên dưới:
>>> a,b,c,d,e=(True, False, False, True, False)
>>> Xor(a,b,c,d,e)Đoạn mã trên cho kết quả sau:
Sai
Hàm Nand
Hàm này thực hiện hoạt động Logical NAND. Nó đánh giá các đối số của nó và trả về True nếu bất kỳ đối số nào trong số chúng là False và False nếu chúng đều đúng.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nand
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nand(a,b,c), Nand(a,c)Đoạn mã trên cho kết quả sau:
(Đúng sai)
Chức năng cũng không
Hàm này thực hiện hoạt động Logical NOR. Nó đánh giá các đối số của nó và trả về Sai nếu bất kỳ đối số nào là Đúng và Đúng nếu tất cả đều là Sai.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nor
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nor(a,b,c), Nor(a,c)Đoạn mã trên cho kết quả sau:
(Sai, Sai)
Lưu ý rằng mặc dù SymPy cung cấp toán tử ^ cho Xor, ~ cho Not, | for Or và & for And là các hàm tiện lợi, việc sử dụng thông thường của chúng trong Python cũng là các toán tử bit. Do đó, nếu toán hạng là số nguyên, kết quả sẽ khác.
Chức năng tương đương
Hàm này trả về quan hệ tương đương. Tương đương (A, B) là Đúng nếu và chỉ khi A và B đều Đúng hoặc cả hai Sai. Hàm trả về True nếu tất cả các đối số là tương đương về mặt logic. Trả về Sai nếu ngược lại.
>>> from sympy import *
>>> from sympy.logic.boolalg import Equivalent
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Equivalent(a,b), Equivalent(a,c)Đoạn mã trên cho kết quả sau:
(Sai đúng)
Chức năng ITE
Hàm này hoạt động như mệnh đề If then else trong ngôn ngữ lập trình .ITE (A, B, C) đánh giá và trả về kết quả của B nếu A là true, nếu không nó sẽ trả về kết quả của C. Tất cả các args phải là Boolean.
>>> from sympy import * >>> from sympy.logic.boolalg import ITE >>> a,b,c=symbols('a b c') >>> a,b,c=(True, False, True)
>>> ITE(a,b,c), ITE(a,c,b)Đoạn mã trên cho kết quả sau:
(Sai đúng)
Mô-đun giả định trong gói SymPy chứa các công cụ để trích xuất thông tin về các biểu thức. Mô-đun định nghĩa hàm ask () cho mục đích này.
sympy.assumptions.ask(property)Các thuộc tính sau cung cấp thông tin hữu ích về một biểu thức:
algebraic(x)
Để trở thành đại số, một số phải là căn của một phương trình đa thức khác 0 với các hệ số hữu tỉ. √2 vì √2 là nghiệm của x2 - 2 = 0 nên nó là nghiệm đại số.
complex(x)
Vị ngữ số phức. Đúng khi và chỉ khi x thuộc tập hợp các số phức.
composite(x)
Vị từ số tổng hợp được trả về bởi ask (Q.composite (x)) là đúng nếu và chỉ khi x là số nguyên dương và có ít nhất một ước số dương khác 1 và chính số đó.
even, odd
Hỏi () trả về true của x nằm trong tập các số chẵn và tập các số lẻ tương ứng.
imaginary
Thuộc tính này đại diện cho vị từ số ảo. Đúng nếu x có thể viết dưới dạng số thực nhân với đơn vị ảo I.
integer
Thuộc tính này do Q.integer (x) trả về trả về true của x thuộc tập hợp các số chẵn.
rational, irrational
Q.irrational (x) đúng nếu và chỉ khi x là bất kỳ số thực nào không thể được biểu diễn dưới dạng tỷ lệ số nguyên. Ví dụ, pi là một số vô tỉ.
positive, negative
Dự đoán để kiểm tra xem số dương hay âm
zero, nonzero
Dự đoán để kiểm tra xem một số có bằng 0 hay không
>>> from sympy import *
>>> x=Symbol('x')
>>> x=10
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask( Q.complex(100))
(True, True)
>>> x,y=symbols("x y")
>>> x,y=5,10
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(False, True)
>>> x,y= 2*I, 4+5*I
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> x,y=5,10
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(False, True, True, False)
>>> x,y=5,-5
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True, True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)Sympy có khả năng đơn giản hóa các biểu thức toán học một cách mạnh mẽ. Có nhiều chức năng trong SymPy để thực hiện nhiều loại đơn giản hóa khác nhau. Một hàm tổng quát được gọi là simplefy () ở đó cố gắng đạt được dạng đơn giản nhất của một biểu thức.
đơn giản hóa
Chức năng này được định nghĩa trong mô-đun evaly.simplify. simplefy () cố gắng áp dụng heuristics thông minh để làm cho biểu thức đầu vào “đơn giản hơn”. Mã sau cho thấy đơn giản hóa biểu thức$sin^2(x)+cos^2(x)$.
>>> from sympy import *
>>> x=Symbol('x')
>>> expr=sin(x)**2 + cos(x)**2
>>> simplify(expr)Đoạn mã trên cho kết quả sau:
1
mở rộng
Mở rộng () là một trong những hàm đơn giản hóa phổ biến nhất trong SymPy, được sử dụng để mở rộng các biểu thức đa thức. Ví dụ -
>>> a,b=symbols('a b')
>>> expand((a+b)**2)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$a^2 + 2ab + b^2$
>>> expand((a+b)*(a-b))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$a^2 - b^2$
Hàm expand () làm cho các biểu thức lớn hơn chứ không phải nhỏ hơn. Thông thường là như vậy, nhưng thường thì một biểu thức sẽ trở nên nhỏ hơn khi gọi hàm expand () trên đó.
>>> expand((x + 1)*(x - 2) - (x - 1)*x)Đoạn mã trên cho kết quả sau:
-2
hệ số
Hàm này nhận một đa thức và nhân nó thành nhân tử bất khả quy trên các số hữu tỉ.
>>> x,y,z=symbols('x y z')
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor(expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$z(x + 2y)^2$
>>> factor(x**2+2*x+1)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$(x + 1)^2$
Hàm factor () ngược lại với hàm expand (). Mỗi nhân tố được trả về bởi factor () được đảm bảo là không thể quy đổi. Hàm factor_list () trả về đầu ra có cấu trúc hơn.
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor_list(expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
(1, [(z, 1), (x + 2*y, 2)])
sưu tầm
Hàm này thu thập các số hạng bổ sung của một biểu thức liên quan đến danh sách biểu thức lên đến lũy thừa với số mũ hợp lý.
>>> expr=x*y + x - 3 + 2*x**2 - z*x**2 + x**3
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^3 + x^2z + 2x^2 + xy + x - 3$
Hàm collect () trên biểu thức này cho kết quả như sau:
>>> collect(expr,x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^3 + x^2(2 - z) + x(y + 1) - 3$
>>> expr=y**2*x + 4*x*y*z + 4*y**2*z+y**3+2*x*y
>>> collect(expr,y)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$Y^3+Y^2(x+4z)+y(4xz+2x)$
hủy bỏ
Hàm hủy () sẽ nhận bất kỳ hàm hữu tỷ nào và đưa nó về dạng chính tắc chuẩn, p / q, trong đó p và q là các đa thức khai triển không có nhân tử chung. Các hệ số hàng đầu của p và q không có mẫu số tức là chúng là số nguyên.
>>> expr1=x**2+2*x+1
>>> expr2=x+1
>>> cancel(expr1/expr2)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x+1$
>>> expr = 1/x + (3*x/2 - 2)/(x - 4)
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{\frac{3x}{2} - 2}{x - 4} + \frac{1}{x}$
>>> cancel(expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{3x^2 - 2x - 8}{2x^2 - 8}$
>>> expr=1/sin(x)**2
>>> expr1=sin(x)
>>> cancel(expr1*expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{1}{\sin(x)}$
trigsimp
Hàm này được sử dụng để đơn giản hóa nhận dạng lượng giác. Có thể lưu ý rằng quy ước đặt tên cho các hàm lượng giác nghịch đảo là thêm một dấu a vào phía trước tên của hàm. Ví dụ, cosin nghịch đảo, hoặc cosin cung, được gọi là acos ().
>>> from sympy import trigsimp, sin, cos
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2
>>> trigsimp(expr)2
Hàm trigsimp sử dụng phương pháp heuristics để áp dụng nhận dạng lượng giác phù hợp nhất.
quyền hạn
Hàm này làm giảm biểu thức đã cho bằng cách kết hợp các lũy thừa với các cơ số và số mũ tương tự.
>>> expr=x**y*x**z*y**z
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^y x^z y^z$
>>> powsimp(expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^{y+z} y^z$
Bạn có thể tạo powsimp () chỉ kết hợp các cơ sở hoặc chỉ kết hợp các số mũ bằng cách thay đổi kết hợp = 'cơ sở' hoặc kết hợp = 'exp'. Theo mặc định, kết hợp = 'tất cả', nghĩa là cả hai. Nếu lực lượng là Đúng thì các cơ sở sẽ được kết hợp mà không cần kiểm tra các giả định.
>>> powsimp(expr, combine='base', force=True)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^y(xy)^z$
combsimp
Biểu thức tổ hợp liên quan đến giai thừa một nhị thức có thể được đơn giản hóa bằng cách sử dụng hàm combsimp (). SymPy cung cấp một hàm thừa ()
>>> expr=factorial(x)/factorial(x - 3)
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{x!}{(x - 3)!}$
Để đơn giản hóa biểu thức tổ hợp trên, chúng ta sử dụng hàm combsimp () như sau:
>>> combsimp(expr)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x(x-2)(x-1)$
Nhị thức (x, y) là số cách chọn y mục từ tập hợp x mục phân biệt. Nó cũng thường được viết là xCy.
>>> binomial(x,y)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$(\frac{x}{y})$
>>> combsimp(binomial(x+1, y+1)/binomial(x, y))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{x + 1}{y + 1}$
logcombine
Hàm này nhận logarit và kết hợp chúng bằng cách sử dụng các quy tắc sau:
- log (x) + log (y) == log (x * y) nếu cả hai đều dương
- a * log (x) == log (x ** a) nếu x dương và a thực
>>> logcombine(a*log(x) + log(y) - log(z))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$a\log(x) + \log(y) - \log(z)$
Nếu tham số lực của hàm này được đặt thành True thì các giả định ở trên sẽ được coi là giữ nguyên nếu không có giả định nào được áp dụng cho một đại lượng.
>>> logcombine(a*log(x) + log(y) - log(z), force=True)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\log\frac{x^a y}{z}$
Đạo hàm của một hàm là tốc độ thay đổi tức thời của nó đối với một trong các biến của nó. Điều này tương đương với việc tìm độ dốc của đường tiếp tuyến với hàm tại một điểm. Chúng ta có thể tìm thấy sự khác biệt của các biểu thức toán học ở dạng các biến bằng cách sử dụng hàm diff () trong gói SymPy.
diff(expr, variable)
>>> from sympy import diff, sin, exp
>>> from sympy.abc import x,y
>>> expr=x*sin(x*x)+1 >>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x\sin(x^2) + 1$
>>> diff(expr,x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$2x^2\cos(x^2) + \sin(x^2)$
>>> diff(exp(x**2),x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
2xex2
Để lấy nhiều đạo hàm, hãy chuyển biến nhiều lần tùy thích để phân biệt hoặc chuyển một số sau biến.
>>> diff(x**4,x,3)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$24x$
>>> for i in range(1,4): print (diff(x**4,x,i))Đoạn mã trên đưa ra biểu thức bên dưới:
4*x**3
12*x**2
24*x
Cũng có thể gọi phương thức diff () của một biểu thức. Nó hoạt động tương tự như hàm diff ().
>>> expr=x*sin(x*x)+1
>>> expr.diff(x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$2x^2\cos(x^2) + \sin(x^2)$
Một đạo hàm không được đánh giá được tạo ra bằng cách sử dụng lớp Đạo hàm. Nó có cùng cú pháp với hàm diff (). Để đánh giá một đạo hàm không được đánh giá, hãy sử dụng phương pháp doit.
>>> from sympy import Derivative
>>> d=Derivative(expr)
>>> dĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{d}{dx}(x\sin(x^2)+1)$
>>> d.doit()Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$2x^2\cos(x^2) + \sin(x^2)$
Gói SymPy chứa mô-đun tích phân. Nó thực hiện các phương pháp để tính tích phân xác định và không xác định của biểu thức. Phương thức tích phân () được sử dụng để tính cả tích phân xác định và tích phân không xác định. Để tính một tích phân không xác định hoặc nguyên thủy, chỉ cần chuyển biến sau biểu thức.
Ví dụ -
integrate(f, x)Để tính một tích phân xác định, hãy chuyển đối số như sau:
(integration_variable, lower_limit, upper_limit)>>> from sympy import *
>>> x,y = symbols('x y')
>>> expr=x**2 + x + 1
>>> integrate(expr, x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{x^3}{3} + \frac{x^2}{2} + x$
>>> expr=sin(x)*tan(x)
>>> expr
>>> integrate(expr,x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$-\frac{\log(\sin(x) - 1)}{2} + \frac{\log(\sin(x) + 1)}{2} - \sin(x)$
Ví dụ về tích phân xác định được đưa ra dưới đây:
>>> expr=exp(-x**2)
>>> integrate(expr,(x,0,oo) )Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{\sqrt\pi}{2}$
Bạn có thể vượt qua nhiều bộ giá trị giới hạn để thực hiện một phép tích phân. Dưới đây là một ví dụ:
>>> expr=exp(-x**2 - y**2)
>>> integrate(expr,(x,0,oo),(y,0,oo))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{\pi}{4}$
Bạn có thể tạo tích phân không đánh giá bằng đối tượng Tích phân, đối tượng này có thể được đánh giá bằng cách gọi phương thức doit ().
>>> expr = Integral(log(x)**2, x)
>>> exprĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\int \mathrm\log(x)^2 \mathrm{d}x$
>>> expr.doit()Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x\log(x)^2 - 2xlog(x) + 2x$
Chuyển đổi tích phân
SymPy hỗ trợ nhiều loại biến đổi tích phân như sau:
- laplace_transform
- fourier_transform
- sine_transform
- cosine_transform
- hankel_transform
Các chức năng này được định nghĩa trong mô-đun evaly.integrals.transforms. Các ví dụ sau đây tính toán biến đổi Fourier và biến đổi Laplace tương ứng.
Example 1
>>> from sympy import fourier_transform, exp
>>> from sympy.abc import x, k
>>> expr=exp(-x**2)
>>> fourier_transform(expr, x, k)Khi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
sqrt(pi)*exp(-pi**2*k**2)Tương đương với -
$\sqrt\pi * e^{\pi^2k^2}$
Example 2
>>> from sympy.integrals import laplace_transform
>>> from sympy.abc import t, s, a
>>> laplace_transform(t**a, t, s)Khi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)Trong Toán học, ma trận là một mảng số, ký hiệu hoặc biểu thức hai chiều. Lý thuyết về thao tác ma trận đề cập đến việc thực hiện các phép tính số học trên các đối tượng ma trận, tuân theo các quy tắc nhất định.
Phép biến đổi tuyến tính là một trong những ứng dụng quan trọng của ma trận. Nhiều lĩnh vực khoa học, đặc biệt liên quan đến Vật lý sử dụng các ứng dụng liên quan đến ma trận.
Gói SymPy có mô-đun ma trận xử lý ma trận. Nó bao gồm lớp Ma trận mà đối tượng của nó đại diện cho một ma trận.
Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −
>>> from sympy.matrices import MatrixExample
>>> from sympy.matrices import Matrix
>>> m=Matrix([[1,2,3],[2,3,1]])
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$Khi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
[1 2 3 2 3 1]
Ma trận được tạo từ các đối tượng List có kích thước phù hợp. Bạn cũng có thể lấy ma trận bằng cách phân phối các mục danh sách theo số hàng và cột đã chỉ định.
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Khi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
[10 40 30 2 6 9]
Ma trận là một đối tượng có thể thay đổi. Mô-đun ma trận cũng cung cấp lớp ImmutableMatrix để thu được ma trận bất biến.
Thao tác cơ bản
Các shape thuộc tính của đối tượng Matrix trả về kích thước của nó.
>>> M.shapeĐầu ra cho đoạn mã trên như sau:
(2,3)
Phương thức row () và col () tương ứng trả về hàng hoặc cột của số được chỉ định.
>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[10 40 30]
>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[40 6]
Sử dụng toán tử lát cắt của Python để tìm nạp một hoặc nhiều mục thuộc hàng hoặc cột.
>>> M.row(1)[1:3]
[6, 9]Lớp ma trận có các phương thức row_del () và col_del () xóa hàng / cột được chỉ định khỏi ma trận đã cho -
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M.col_del(1)
>>> MKhi thực hiện lệnh trên trong python shell, kết quả sau sẽ được tạo:
Matrix([[10, 30],[ 2, 9]])Bạn có thể áp dụng kiểu cho đầu ra bằng lệnh sau:
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[10 30 2 9]
>>> M.row_del(0)
>>> M
$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[2 9]
Tương tự, các phương thức row_insert () và col_insert () thêm hàng hoặc cột tại chỉ mục hàng hoặc cột được chỉ định
>>> M1=Matrix([[10,30]])
>>> M=M.row_insert(0,M1)
>>> M
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[10 40 30 2 9]
>>> M2=Matrix([40,6])
>>> M=M.col_insert(1,M2)
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[10 40 30 6 9]
Các phép tính toán học
Các toán tử thông thường +, - và * được định nghĩa để thực hiện các phép cộng, trừ và nhân.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5,6],[6,5,4]])
>>> M1+M2
$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[5 7 9 9 7 5]
>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[- 3 -3 -3 -3 -3 -3]
Phép nhân ma trận chỉ có thể thực hiện được nếu - Số cột của ma trận thứ nhất phải bằng số hàng của ma trận thứ hai. - Và kết quả sẽ có cùng số hàng với ma trận thứ 1 và cùng số cột với ma trận thứ 2.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5],[6,6],[5,4]])
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[31 29 29 31]
>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$Kết quả sau nhận được sau khi thực thi mã:
[1 3 2 2 3 1]
Để tính định thức của ma trận, sử dụng phương pháp det (). Định thức là một giá trị vô hướng có thể được tính toán từ các phần tử của ma trận vuông.
>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[10 20 30 5 8 12 9 6 15]
>>> M.det()Đầu ra cho đoạn mã trên như sau:
-120
Trình tạo ma trận
SymPy cung cấp nhiều kiểu lớp ma trận đặc biệt. Ví dụ, ma trận nhận dạng, ma trận của tất cả các số 0 và một, v.v. Các lớp này được đặt tên tương ứng là mắt, số không và số một. Ma trận nhận dạng là một ma trận vuông với các phần tử nằm trên đường chéo được đặt là 1, các phần tử còn lại là 0.
Example
from sympy.matrices import eye eye(3)Output
Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[1 0 0 0 1 0 0 0 1]
Trong ma trận đường chéo, các phần tử trên đường chéo được khởi tạo theo các đối số được cung cấp.
>>> from sympy.matrices import diag
>>> diag(1,2,3)
$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[1 0 0 0 2 0 0 0 3]
Tất cả các phần tử trong ma trận số không được khởi tạo bằng 0.
>>> from sympy.matrices import zeros
>>> zeros(2,3)
$\displaystyle \left[\begin{matrix}0 & 0 & 0\\0 & 0 & 0\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[0 0 0 0 0 0]
Tương tự, những cái là ma trận với tất cả các phần tử được đặt thành 1.
>>> from sympy.matrices import ones
>>> ones(2,3)
$\displaystyle \left[\begin{matrix}1 & 1 & 1\\1 & 1 & 1\end{matrix}\right]$Đầu ra cho đoạn mã trên như sau:
[1 1 1 1 1 1]
Gói Sympy có lớp Chức năng, được định nghĩa trong mô-đun sympy.core. Chức năng. Nó là một lớp cơ sở cho tất cả các hàm toán học được áp dụng, cũng như một hàm tạo cho các lớp hàm không xác định.
Các loại hàm sau được kế thừa từ lớp Hàm:
- Các hàm cho số phức
- Hàm lượng giác
- Các hàm cho số nguyên
- Chức năng kết hợp
- Các chức năng khác
Các hàm cho số phức
Bộ chức năng này được định nghĩa trong sympy.functions.elementary.complexes mô-đun.
re
Hàm này trả về một phần thực của một biểu thức -
>>> from sympy import *
>>> re(5+3*I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
5
>>> re(I)Đầu ra cho đoạn mã trên là -
0
Im
Hàm này trả về phần ảo của một biểu thức -
>>> im(5+3*I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
3
>>> im(I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
1
sign
Hàm này trả về dấu phức của một biểu thức.
Đối với biểu thức thực, dấu hiệu sẽ là:
- 1 nếu biểu thức là số dương
- 0 nếu biểu thức bằng 0
- -1 nếu biểu thức là âm
Nếu biểu thức là ảo thì dấu được trả về là -
- I if im (biểu thức) là tích cực
- -Tôi nếu im (biểu thức) là âm
>>> sign(1.55), sign(-1), sign(S.Zero)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(1, -1, 0)
>>> sign (-3*I), sign(I*2)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(-I, I)
Abs
Hàm này trả về giá trị tuyệt đối của một số phức. Nó được định nghĩa là khoảng cách giữa điểm gốc (0,0) và điểm (a, b) trong mặt phẳng phức. Hàm này là một phần mở rộng của hàm abs () tích hợp sẵn để chấp nhận các giá trị tượng trưng.
>>> Abs(2+3*I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
$\sqrt13$
conjugate
Hàm này trả về liên hợp của một số phức. Để tìm liên hợp phức chúng ta đổi dấu của phần ảo.
>>> conjugate(4+7*I)Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
4 - 7i
Hàm lượng giác
SymPy có định hướng cho tất cả các tỷ lệ lượng giác - sin cos, tan, v.v. cũng như các đối số nghịch đảo của nó như asin, acos, atan, v.v. Các hàm này tính giá trị tương ứng cho góc đã cho được biểu thị bằng radian.
>>> sin(pi/2), cos(pi/4), tan(pi/6)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(1, sqrt(2)/2, sqrt(3)/3)
>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(pi/2, pi/4, pi/6)
Các hàm trên số nguyên
Đây là một tập hợp các hàm để thực hiện các phép toán khác nhau trên số nguyên.
ceiling
Đây là một hàm đơn biến trả về giá trị số nguyên nhỏ nhất không nhỏ hơn đối số của nó. Trong trường hợp số phức, trần của phần thực và phần ảo riêng biệt.
>>> ceiling(pi), ceiling(Rational(20,3)), ceiling(2.6+3.3*I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(4, 7, 3 + 4*I)
floor
Hàm này trả về giá trị số nguyên lớn nhất không lớn hơn đối số của nó. Trong trường hợp là số phức, hàm này cũng lấy tầng của phần thực và phần ảo riêng biệt.
>>> floor(pi), floor(Rational(100,6)), floor(6.3-5.9*I)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(3, 16, 6 - 6*I)
frac
Hàm này biểu diễn phần phân số của x.
>>> frac(3.99), frac(Rational(10,3)), frac(10)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
(0.990000000000000, 1/3, 0)
Chức năng kết hợp
Tổ hợp là một lĩnh vực toán học liên quan đến các vấn đề về lựa chọn, sắp xếp và vận hành trong một hệ thống hữu hạn hoặc rời rạc.
factorial
Giai thừa rất quan trọng trong tổ hợp, nó cho biết số cách mà n đối tượng có thể được hoán vị. Nó được biểu thị một cách tượng trưng là ð ?? '¥! Hàm này thực hiện chức năng giai thừa trên các số nguyên không âm, giai thừa của một số nguyên âm là phức vô cùng.
>>> x=Symbol('x')
>>> factorial(x)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
x!
>>> factorial(5)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
120
>>> factorial(-1)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
$\infty\backsim$
nhị thức
Hàm này có số cách chúng ta có thể chọn k phần tử từ tập hợp n phần tử.
>>> x,y=symbols('x y')
>>> binomial(x,y)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
$(\frac{x}{y})$
>>> binomial(4,2)Đầu ra cho đoạn mã trên được đưa ra bên dưới:
6
Các hàng của tam giác Pascal có thể được tạo ra bằng hàm nhị thức.
>>> for i in range(5): print ([binomial(i,j) for j in range(i+1)])Bạn nhận được kết quả đầu ra sau khi thực hiện đoạn mã trên -
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
fibonacci
Các số Fibonacci là dãy số nguyên được xác định bởi các số hạng ban đầu F0 = 0, F1 = 1 và quan hệ lặp lại hai số hạng Fn = Fnâˆ'1 + Fnâˆ'2.
>>> [fibonacci(x) for x in range(10)]Kết quả sau nhận được sau khi thực thi đoạn mã trên:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
tribonacci
Các số Tribonacci là dãy số nguyên được xác định bởi các số hạng ban đầu F0 = 0, F1 = 1, F2 = 1 và quan hệ lặp lại ba số hạng Fn = Fn-1 + Fn-2 + Fn-3.
>>> tribonacci(5, Symbol('x'))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^8 + 3x^5 + 3x^2$
>>> [tribonacci(x) for x in range(10)]Kết quả sau nhận được sau khi thực thi đoạn mã trên:
[0, 1, 1, 2, 4, 7, 13, 24, 44, 81]
Các chức năng khác
Sau đây là danh sách một số hàm thường được sử dụng:
Min- Trả về giá trị nhỏ nhất của danh sách. Nó được đặt tên là Min để tránh xung đột với hàm min tích hợp sẵn.
Max- Trả về giá trị lớn nhất của danh sách. Nó được đặt tên là Max để tránh xung đột với hàm max được tích hợp sẵn.
root - Trả về căn thứ n của x.
sqrt - Trả về căn bậc hai chính của x.
cbrt - Hàm này tính toán gốc khối chính của x, (phím tắt cho x ++ Rational (1,3)).
Sau đây là các ví dụ về các hàm linh tinh ở trên và kết quả đầu ra tương ứng của chúng:
>>> Min(pi,E)e
>>> Max(5, Rational(11,2))$\frac{11}{2}$
>>> root(7,Rational(1,2))49
>>> sqrt(2)$\sqrt2$
>>> cbrt(1000)10
Trong toán học, hệ thống số Quaternion là sự mở rộng của các số phức. Mỗi đối tượng Quaternion chứa bốn biến vô hướng và bốn chiều, một chiều thực và ba chiều ảo.
Quaternion được biểu diễn bằng biểu thức sau:
q = a + bi + cj + dk
Ở đâu a, b, c và d là số thực và i, j, k là các đơn vị quaternion như vậy, i2 == j2 == k2 == ijk
Các sympy.algebras.quaternion mô-đun có lớp Quaternion.
>>> from sympy.algebras.quaternion import Quaternion
>>> q=Quaternion(2,3,1,4)
>>> qĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$2 + 3i + 1j + 4k$
Quaternion được sử dụng trong toán học thuần túy, cũng như trong toán học ứng dụng, đồ họa máy tính, thị giác máy tính, v.v.
>>> from sympy import *
>>> x=Symbol('x')
>>> q1=Quaternion(x**2, x**3, x) >>> q1Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$x^2 + x^3i + xj + 0k$
Đối tượng Quaternion cũng có thể có hiệu suất tưởng tượng
>>> q2=Quaternion(2,(3+2*I), x**2, 3.5*I)
>>> q2Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$2 + (3 + 2i)i + x2j + 3.5ik$
thêm vào()
Phương thức này có sẵn trong lớp Quaternion thực hiện phép cộng hai đối tượng Quaternion.
>>> q1=Quaternion(1,2,3,4)
>>> q2=Quaternion(4,3,2,1)
>>> q1.add(q2)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$5 + 5i + 5j + 5k$
Có thể thêm một số hoặc biểu tượng trong một đối tượng Quaternion.
>>> q1+2Kết quả sau nhận được sau khi thực thi đoạn mã trên:
$3 + 2i + 3j + 4k$
>>> q1+xKết quả sau nhận được sau khi thực thi đoạn mã trên:
$(x + 1) + 2i + 3j + 4k$
mul ()
Phương thức này thực hiện phép nhân hai đối tượng quaternion.
>>> q1=Quaternion(1,2,1,2)
>>> q2=Quaternion(2,4,3,1)
>>> q1.mul(q2)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$(-11) + 3i + 11j + 7k$
nghịch đảo ()
Phương thức này trả về nghịch đảo của một đối tượng quaternion.
>>> q1.inverse()Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{1}{10} + (-\frac{1}{5})i + (-\frac{1}{10})j + (-\frac{1}{5})k$
pow ()
Phương thức này trả về sức mạnh của một đối tượng quaternion.
>>> q1.pow(2)Kết quả sau nhận được sau khi thực thi đoạn mã trên:
$(-8) + 4i + 2j + 4k$
exp ()
Phương thức này tính toán hàm mũ của một đối tượng Quaternion tức là eq
>>> q=Quaternion(1,2,4,3)
>>> q.exp()Kết quả sau nhận được sau khi thực thi đoạn mã trên:
$e\cos(\sqrt29) + \frac{2\sqrt29e\sin(\sqrt29)}{29}i + \frac{4\sqrt29e\sin(\sqrt29)}{29}j + \frac{3\sqrt29e\sin}{29}k$
Vì các ký hiệu = và == được định nghĩa là các toán tử gán và bình đẳng trong Python, chúng không thể được sử dụng để lập phương trình ký hiệu. SymPy cung cấp hàm Eq () để thiết lập một phương trình.
>>> from sympy import *
>>> x,y=symbols('x y')
>>> Eq(x,y)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
x = y
Vì x = y khả thi nếu và chỉ khi xy = 0, phương trình trên có thể được viết dưới dạng:
>>> Eq(x-y,0)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
x − y = 0
Mô-đun bộ giải trong SymPy cung cấp hàm soveset () có nguyên mẫu như sau:
solveset(equation, variable, domain)Miền theo mặc định là S.Complexes. Sử dụng hàm solveset (), chúng ta có thể giải một phương trình đại số như sau:
>>> solveset(Eq(x**2-9,0), x)Kết quả sau thu được:
{−3, 3}
>>> solveset(Eq(x**2-3*x, -2),x)Kết quả sau nhận được sau khi thực thi đoạn mã trên:
{1,2}
Đầu ra của tập giải là một Tập hữu hạn của các giải pháp. Nếu không có giải pháp nào, EmptySet được trả về
>>> solveset(exp(x),x)Kết quả sau nhận được sau khi thực thi đoạn mã trên:
$\varnothing$
Phương trình đường thẳng
Chúng ta phải sử dụng hàm linsolve () để giải các phương trình tuyến tính.
Ví dụ, các phương trình như sau:
xy = 4
x + y = 1
>>> from sympy import *
>>> x,y=symbols('x y')
>>> linsolve([Eq(x-y,4),Eq( x + y ,1) ], (x, y))Kết quả sau nhận được sau khi thực thi đoạn mã trên:
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
Hàm linsolve () cũng có thể giải các phương trình tuyến tính được biểu diễn dưới dạng ma trận.
>>> a,b=symbols('a b')
>>> a=Matrix([[1,-1],[1,1]])
>>> b=Matrix([4,1])
>>> linsolve([a,b], (x,y))Chúng tôi nhận được kết quả đầu ra sau đây nếu chúng tôi thực thi đoạn mã trên -
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
Phương trình phi tuyến tính
Với mục đích này, chúng tôi sử dụng hàm nonlinsolve (). Phương trình cho ví dụ này -
a 2 + a = 0 ab = 0
>>> a,b=symbols('a b')
>>> nonlinsolve([a**2 + a, a - b], [a, b])Chúng tôi nhận được kết quả đầu ra sau đây nếu chúng tôi thực thi đoạn mã trên -
$\lbrace(-1, -1),(0,0)\rbrace$
phương trình vi phân
Đầu tiên, tạo một hàm không xác định bằng cách chuyển hàm cls = Hàm cho hàm ký hiệu. Để giải phương trình vi phân, hãy sử dụng dsolve.
>>> x=Symbol('x')
>>> f=symbols('f', cls=Function)
>>> f(x)Kết quả sau nhận được sau khi thực thi đoạn mã trên:
f(x)
Ở đây f (x) là một hàm vô nghiệm. Đạo hàm của nó như sau:
>>> f(x).diff(x)Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$\frac{d}{dx}f(x)$
Đầu tiên chúng ta tạo đối tượng Eq tương ứng với phương trình vi phân sau
>>> eqn=Eq(f(x).diff(x)-f(x), sin(x))
>>> eqnĐoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$-f(x) + \frac{d}{dx}f(x)= \sin(x)$
>>> dsolve(eqn, f(x))Đoạn mã trên cho kết quả tương đương với biểu thức bên dưới:
$f(x)=(c^1-\frac{e^-xsin(x)}{2}-\frac{e^-xcos(x)}{2})e^x$
SymPy sử dụng thư viện Matplotlib làm chương trình phụ trợ để hiển thị các ô 2-D và 3-D của các hàm toán học. Đảm bảo rằng Matplotlib có sẵn trong cài đặt Python hiện tại. Nếu không, hãy cài đặt tương tự bằng lệnh sau:
pip install matplotlibHỗ trợ vẽ đồ thị được định nghĩa trong mô-đun Treaty.plotting. Các chức năng sau có trong mô-đun vẽ đồ thị:
plot - Các ô đường thẳng 2D
plot3d - Biểu đồ đường 3D
plot_parametric - Các ô tham số 2D
plot3d_parametric - Biểu đồ tham số 3D
Hàm plot () trả về một thể hiện của lớp Plot. Một hình vẽ có thể có một hoặc nhiều biểu thức SymPy. Mặc dù nó có khả năng sử dụng Matplotlib làm chương trình phụ trợ, các phần mềm phụ trợ khác như texplot, pyglet hoặc API biểu đồ của Google cũng có thể được sử dụng.
plot(expr, range, kwargs)trong đó expr là bất kỳ biểu thức symPy hợp lệ nào. Nếu không được đề cập, phạm vi sử dụng mặc định là (-10, 10).
Ví dụ sau vẽ các giá trị của x2 cho mỗi giá trị trong phạm vi (-10,10) -
>>> from sympy.plotting import plot
>>> from sympy import *
>>> x=Symbol('x')
>>> plot(x**2, line_color='red')
Để vẽ nhiều ô cho cùng một dải ô, hãy đưa ra nhiều biểu thức trước bộ dải ô.
>>> plot( sin(x),cos(x), (x, -pi, pi))
Bạn cũng có thể chỉ định phạm vi riêng biệt cho từng biểu thức.
plot((expr1, range1), (expr2, range2))Hình sau vẽ biểu đồ sin (x) và cos (x) trên các khoảng khác nhau.
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)))
Các đối số từ khóa tùy chọn sau đây có thể được chỉ định trong hàm plot ().
line_color - chỉ định màu của đường vẽ.
title - một chuỗi được hiển thị dưới dạng tiêu đề
xlabel - một chuỗi được hiển thị dưới dạng nhãn cho trục X
ylabel - một chuỗi được hiển thị dưới dạng nhãn cho trục y
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)), line_color='red', title='SymPy plot example')
Hàm plot3d () hiển thị một biểu đồ ba chiều.
plot3d(expr, xrange, yrange, kwargs)Ví dụ sau đây vẽ sơ đồ bề mặt 3D:
>>> from sympy.plotting import plot3d
>>> x,y=symbols('x y')
>>> plot3d(x*y, (x, -10,10), (y, -10,10))
Như trong cốt truyện 2D, một biểu đồ ba chiều cũng có thể có nhiều ô với phạm vi khác nhau.
>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))
Hàm plot3d_parametric_line () hiển thị biểu đồ đường tham số 3 chiều.
>>> from sympy.plotting import plot3d_parametric_line
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))
Để vẽ biểu đồ bề mặt tham số, hãy sử dụng hàm plot3d_parametric_surface ().
plot3d_parametric_surface(xexpr, yexpr, zexpr, rangex, rangey, kwargs)
>>> from sympy.plotting import plot3d_parametric_surface
>>> plot3d_parametric_surface(cos(x+y), sin(x-y), x-y, (x, -5, 5), (y, -5, 5))
Mô-đun hình học trong SymPy cho phép tạo các thực thể hai chiều như đường thẳng, hình tròn, v.v. Sau đó, chúng ta có thể lấy thông tin về chúng, chẳng hạn như kiểm tra cột hoặc tìm giao điểm.
Điểm
Lớp điểm biểu diễn một điểm trong không gian Euclide. Ví dụ sau kiểm tra tính thẳng hàng của các điểm:
>>> from sympy.geometry import Point
>>> from sympy import *
>>> x=Point(0,0)
>>> y=Point(2,2)
>>> z=Point(4,4)
>>> Point.is_collinear(x,y,z)Output
True
>>> a=Point(2,3)
>>> Point.is_collinear(x,y,a)Output
False
Phương thức distance () của lớp Point tính toán khoảng cách giữa hai điểm
>>> x.distance(y)Output
$2\sqrt2$
Khoảng cách cũng có thể được biểu diễn dưới dạng ký hiệu.
Hàng
Thực thể đường được lấy từ hai đối tượng Point. Phương thức giao điểm () trả về điểm giao nhau nếu hai đường thẳng cắt nhau.
>>> from sympy.geometry import Point, Line
>>> p1, p2=Point(0,5), Point(5,0)
>>> l1=Line(p1,p2)
>>> l2=Line(Point(0,0), Point(5,5))
>>> l1.intersection(l2)Output
[Point2D(5/2, 5/2)]
>>> l1.intersection(Line(Point(0,0), Point(2,2)))Output
[Point2D(5/2, 5/2)]
>>> x,y=symbols('x y')
>>> p=Point(x,y)
>>> p.distance(Point(0,0))Output
$\sqrt{x^2 + y^2}$
Tam giác
Hàm này xây dựng một thực thể tam giác từ ba đối tượng điểm.
Triangle(a,b,c)
>>> t=Triangle(Point(0,0),Point(0,5), Point(5,0))
>>> t.areaOutput
$-\frac{25}{2}$
Hình elip
Một thực thể hình học elip được xây dựng bằng cách truyền một đối tượng Điểm tương ứng với tâm và hai số cho mỗi bán kính ngang và dọc.
ellipse(center, hradius, vradius)
>>> from sympy.geometry import Ellipse, Line
>>> e=Ellipse(Point(0,0),8,3)
>>> e.areaOutput
$24\pi$
Vradius có thể được cung cấp gián tiếp bằng cách sử dụng tham số độ lệch tâm.
>>> e1=Ellipse(Point(2,2), hradius=5, eccentricity=Rational(3,4))
>>> e1.vradiusOutput
$\frac{5\sqrt7}{4}$
Các apoapsis của hình elip là khoảng cách lớn nhất giữa tiêu điểm và đường viền.
>>> e1.apoapsisOutput
$\frac{35}{4}$
Câu lệnh sau đây tính toán chu vi của hình elip:
>>> e1.circumferenceOutput
$20E(\frac{9}{16})$
Các equation phương thức ellipse trả về phương trình của ellipse.
>>> e1.equation(x,y)Output
$(\frac{x}{5}-\frac{2}{5})^2 + \frac{16(y-2)2}{175} - 1$
Trong toán học, tập hợp là một tập hợp được xác định rõ ràng của các đối tượng riêng biệt có thể là số, người, chữ cái trong bảng chữ cái hoặc thậm chí là các tập hợp khác. Set cũng là một trong những kiểu dựng sẵn trong Python. SymPy cung cấp mô-đun bộ. Nó chứa các định nghĩa về các loại tập hợp khác nhau và có chức năng để thực hiện các thao tác tập hợp như giao nhau, kết hợp, v.v.
Tập hợp là một lớp cơ sở cho bất kỳ loại tập hợp nào khác trong SymPy. Lưu ý rằng nó khác với kiểu dữ liệu tập hợp tích hợp sẵn của Python. Lớp khoảng thời gian biểu thị các khoảng thời gian thực và thuộc tính biên của nó trả vềFiniteSet vật.
>>> from sympy import Interval
>>> s=Interval(1,10).boundary
>>> type(s)sympy.sets.sets.FiniteSet
FiniteSet là một tập hợp các số rời rạc. Nó có thể được lấy từ bất kỳ đối tượng trình tự nào như danh sách hoặc chuỗi.
>>> from sympy import FiniteSet
>>> FiniteSet(range(5))Output
$\lbrace\lbrace0,1,...,4\rbrace\rbrace$
>>> numbers=[1,3,5,2,8]
>>> FiniteSet(*numbers)Output
$\lbrace1,2,3,5,8\rbrace$
>>> s="HelloWorld"
>>> FiniteSet(*s)Output
{H,W,d,e,l,o,r}
Lưu ý rằng, giống như trong tập hợp dựng sẵn, SymPy's Set cũng là một tập hợp các đối tượng riêng biệt.
ConditionSet là một tập hợp các phần tử thỏa mãn một điều kiện nhất định
>>> from sympy import ConditionSet, Eq, Symbol
>>> x=Symbol('x')
>>> s=ConditionSet(x, Eq(x**2-2*x,0), Interval(1,10)) >>> sOutput
$\lbrace x\mid x\in[1,10]∧x^2 - 2x =0\rbrace$
Unionlà một tập hợp. Nó bao gồm tất cả các phần tử trong hai tập hợp. Lưu ý rằng các yếu tố được tìm thấy trong cả hai, sẽ chỉ xuất hiện một lần trong Liên minh.
>>> from sympy import Union
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Union(a,b)Intersection mặt khác chỉ chứa những yếu tố có trong cả hai.
>>> from sympy import Intersection
>>> Intersection(a,b)ProductSet đối tượng đại diện cho tích Descartes của các phần tử trong cả hai tập hợp.
>>> from sympy import ProductSet
>>> l1=[1,2]
>>> l2=[2,3]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> set(ProductSet(a,b))Complement(a,b) giữ lại các phần tử trong một tập hợp loại trừ các phần tử chung với tập hợp b.
>>> from sympy import Complement
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Complement(a,b), Complement(b,a)SymmetricDifference tập hợp chỉ chứa các phần tử không phổ biến trong cả hai tập hợp.
>>> from sympy import SymmetricDifference
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> SymmetricDifference(a,b)Output
{2,3,5,9}
Có một số máy in có sẵn trong SymPy. Sau đây là một phần danh sách -
- str
- srepr
- Máy in đẹp ASCII
- Máy in Unicode đẹp
- LaTeX
- MathML
- Dot
Các đối tượng SymPy cũng có thể được gửi dưới dạng đầu ra cho mã của nhiều ngôn ngữ khác nhau, chẳng hạn như C, Fortran, Javascript, Theano và Python.
SymPy sử dụng các ký tự Unicode để hiển thị đầu ra dưới dạng bản in đẹp. Nếu bạn đang sử dụng bảng điều khiển Python để thực thi phiên SymPy, môi trường in ấn đẹp nhất được kích hoạt bằng cách gọi hàm init_session ().
>>> from sympy import init_session
>>> init_session()Bảng điều khiển IPython dành cho SymPy 1.5.1 (Python 3.7.4-64-bit) (loại mặt đất: python).
Các lệnh này đã được thực thi -
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()Tài liệu có thể được tìm thấy tại https://docs.sympy.org/1.5.1/.
>>> Integral(sqrt(1/x),x)$\int \sqrt\frac{1}{x} dx$
Nếu LATEX chưa được cài đặt, nhưng Matplotlib được cài đặt, nó sẽ sử dụng công cụ kết xuất Matplotlib. Nếu Matplotlib không được cài đặt, nó sử dụng máy in Unicode khá đẹp. Tuy nhiên, sổ ghi chép Jupyter sử dụng MathJax để kết xuất LATEX.
Trong một thiết bị đầu cuối không hỗ trợ Unicode, máy in ASCII khá được sử dụng.
Để sử dụng máy in ASCII, hãy sử dụng hàm pprint () với thuộc tính use_unicode được đặt thành Sai
>>> pprint(Integral(sqrt(1/x),x),use_unicode=False)
Máy in khá Unicode cũng được truy cập từ pprint () và khá (). Nếu thiết bị đầu cuối hỗ trợ Unicode, nó sẽ được sử dụng tự động. Nếu pprint () không thể phát hiện rằng thiết bị đầu cuối hỗ trợ unicode, bạn có thể chuyển use_unicode = True để buộc nó sử dụng Unicode.
Để nhận dạng LATEX của một biểu thức, hãy sử dụng hàm latex ().
>>> print(latex(Integral(sqrt(1/x),x)))\int \sqrt{\frac{1}{x}}\, dx
Bạn cũng có thể sử dụng máy in mathml. cho mục đích đó, hãy nhập hàm print_mathml. Một phiên bản chuỗi được lấy bởi hàm mathml ().
>>> from sympy.printing.mathml import print_mathml
>>> print_mathml(Integral(sqrt(1/x),x))<apply>
<int/>
<bvar>
<ci>x</ci>
</bvar>
<apply>
<root/>
<apply>
<power/>
<ci>x</ci>
<cn>-1</cn>
</apply>
</apply>
</apply>
>>>mathml(Integral(sqrt(1/x),x))'<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn>-1</cn></apply></apply></apply>'