SymPy: Panduan Lengkap Matematika Simbolik di Python

Jika Anda pernah berharap Python dapat melakukan dan menuliskan operasi aljabar seperti seorang matematikawan, SymPy adalah jawabannya.

SymPy adalah singkatan dari Symbolic Python, dan ini adalah pustaka untuk melakukan komputasi simbolik, artinya ia dapat mengembangkan, menyederhanakan, mendiferensiasi, dan menyelesaikan persamaan secara simbolik, seperti yang Anda lakukan di atas kertas.  Perluasan pentingnya adalah bahwa ekspresi matematika dengan variabel yang belum dievaluasi dibiarkan dalam bentuk simbolik. Misalnya, akar kuadrat dari delapan akan direpresentasikan sebagai 2*sqrt(2), alih-alih mendekatkannya menjadi 2.828.   

Beberapa keunggulan utama SymPy adalah bersifat open source, sepenuhnya ditulis dalam Python, dan menawarkan kompatibilitas dengan pustaka Python lainnya. 

Keunggulan utama Sympy. Sumber: Gambar oleh Napkin AI

Sejarah Singkat SymPy

SymPy dimulai dengan ide sederhana: membuat komputasi simbolik dapat diakses oleh semua orang.

Proyek ini dimulai pada 2006 oleh Ondřej Čertík, seorang mahasiswa di University of Nevada. Ia ingin membuat pustaka matematika simbolik yang ringan dan fleksibel dalam Python murni sehingga orang tidak perlu berurusan dengan kompleksitas sistem aljabar komputer besar seperti Maple atau Mathematica. 

Antara 2007 dan 2010, SymPy tumbuh pesat saat berpartisipasi dalam Google Summer of Code, di mana modul inti utama seperti simplifikasi, pemecahan, dan kalkulus berkembang signifikan. 

Sekitar tahun 2012, SymPy telah cukup matang hingga diintegrasikan ke dalam SageMath, menandai pengakuannya sebagai backend simbolik yang andal dalam ekosistem Python ilmiah yang lebih luas. Saat ini, SymPy telah berkembang melampaui penggunaannya di aljabar ke ranah lanjutan termasuk fisika, geometri, kombinatorika, pembangkitan kode, dan alat kompilasi berorientasi kinerja.

Mulai Menggunakan SymPy

Sebelum mengeksplorasi “sihir” SymPy, mari kita atur terlebih dahulu dengan benar.

Instalasi dan penyiapan

Cara termudah sekaligus yang direkomendasikan untuk memasang SymPy adalah menggunakan pip:

pip install sympyDidukung oleh

Jika Anda menggunakan Conda, perintahnya:

conda install sympyDidukung oleh

Sebagai alternatif, Anda dapat memasang langsung dari sumber (berguna untuk kontributor):

git clone https://github.com/sympy/sympy.gitDidukung oleh

Jika Anda bertanya soal dependensi: SymPy sepenuhnya berjalan di Python dan tidak bergantung pada pustaka eksternal. Paket opsional seperti mpmath dapat dipasang untuk aritmetika presisi sewenang-wenang:

pip install mpmathDidukung oleh

Memverifikasi instalasi

Untuk memastikan instalasi, buka Python dan ketik:

import sympy
print(sympy.__version__)Didukung oleh

1.14.0Didukung oleh

Keluaran menunjukkan versi paket yang terpasang.  Anda kini bisa menguji paket dengan ekspresi sederhana:

from sympy import symbols

# Define x as a symbolic variable
x = symbols('x')

print((x + 2)**2)Didukung oleh

(x + 2)**2Didukung oleh

Untuk pemecahan masalah:

• Jika Anda melihat ModuleNotFoundError, jalankan lagi pip install sympy.

• Untuk konflik versi, tingkatkan pip: pip install --upgrade pip

Selain itu, yang baik untuk diketahui: Jika Anda pikir ada bug atau ingin meminta fitur, Anda juga dapat mbuka tiket isu. Untuk penjelajahan rinci tentang metode instalasi, lihat dokumentasi resmi.

Penggunaan dasar

SymPy menyediakan lingkungan interaktif tempat Anda dapat memanipulasi ekspresi aljabar secara simbolik.

from sympy import symbols, expand

#define x and y as symbolic variables
x, y = symbols('x y')

# create an algebraic expression
expr = (x + y)**2

expanded = expand(expr)
print(expanded)Didukung oleh

x**2 + 2*x*y + y**2Didukung oleh

Keluaran tercetak di atas x**2 + 2*x*y + y**2 adalah bentuk yang sepenuhnya dikembangkan, menunjukkan bagaimana SymPy melakukan aljabar simbolik tepat alih-alih komputasi numerik.

Fitur dan Fungsionalitas Inti

Fungsionalitas inti dibangun di sekitar komputasi simbolik — artinya bekerja dengan fungsi, persamaan, dan ekspresi sebagai simbol, bukan angka.

Operasi aritmetika

Anda dapat memperlakukan variabel simbolik seperti variabel aljabar. Selain itu, fungsi dapat berpindah dari satu bentuk ke bentuk lain seperti ditunjukkan pada kode di bawah. 

Dengan menggunakan expand() untuk distribusi dan factor() untuk penyederhanaan balik, SymPy bertransformasi antara bentuk dikembangkan dan difaktorkan dari sebuah ekspresi aljabar.

from sympy import symbols, expand, factor

# Define symbolic variables x and y
x, y = symbols('x y')

# Create an algebraic expression
expr = (x + y)**2

# Expand the expression to its full polynomial form
print(expand(expr))  

# Factor the expanded polynomial back into its compact form
print(factor(x**2 + 2*x*y + y**2)) Didukung oleh

x**2 + 2*x*y + y**2
(x + y)**2Didukung oleh

Teknik penyederhanaan

Penyederhanaan adalah inti dari komputasi simbolik. Ada fungsi umum di Sympy, bernama simplify(),  yang digunakan untuk menyederhanakan ekspresi rasional, trigonometri, atau aljabar dengan mudah.

from sympy import simplify, trigsimp, sin, cos

# Create a trigonometric expression
expr = sin(x)**2 + cos(x)**2

# General simplification — recognizes that sin²x + cos²x = 1
print(simplify(expr)) 

# Trigonometric-specific simplification — also simplifies to 1
print(trigsimp(expr)) Didukung oleh

Keluaran pada kedua fungsi simplify() dan trigsimp() di atas bernilai satu. 

Operasi kalkulus

SymPy sangat baik untuk kalkulus karena memungkinkan Anda melakukan diferensiasi, integrasi, limit, dan bahkan pengembangan deret semuanya secara simbolik, seperti menyelesaikan dengan tangan namun dengan akurasi sempurna.

Diferensiasi

Untuk mengambil turunan, gunakan fungsi diff().

from sympy import diff

# Define a symbolic polynomial expression
f = x**3 + 2*x**2 + x

# Compute the derivative of the expression with respect to x
df = diff(f, x)
print(df)Didukung oleh

3*x**2 + 4*x + 1Didukung oleh

Integrasi

Kode di bawah menghitung integral tak tentu dari ekspresi simbolik f terhadap variabel x menggunakan fungsi integrate() milik SymPy. Antiturunan yang dihasilkan kemudian dicetak.

from sympy import integrate

# Compute the indefinite integral of the expression f with respect to x
integral = integrate(f, x)
print(integral)Didukung oleh

x**4/4 + 2*x**3/3 + x**2/2Didukung oleh

Limit

Perhitungan limit adalah operasi klasik dalam kalkulus, yang dapat dilakukan menggunakan fungsi limit() SymPy. Sintaksnya: limit(f(x), x, x0).  Sebagai contoh, kode di bawah menghitung limit dari ekspresi sin(x)/x saat x mendekati nol dan mencetak hasil tepatnya, satu. 

from sympy import limit, sin

# Compute the limit of sin(x)/x as x approaches 0 
limit_expr = limit(sin(x)/x, x, 0)
print(limit_expr) Didukung oleh

Pengembangan deret

Fungsi series() dapat digunakan untuk menghitung pengembangan deret Taylor atau deret pangkat dari suatu ekspresi matematika di sekitar titik tertentu.

from sympy import series, exp

# Generate the Taylor series expansion of e^x around 0 up to 5 terms
print(series(exp(x), x, 0, 5))Didukung oleh

1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)Didukung oleh

Penjumlahan

Fungsi summation() di SymPy melakukan penjumlahan simbolik tepat pada rentang tertentu, seperti notasi sigma dalam matematika.

from sympy import summation, symbols

# Compute the symbolic sum of 1/n^2 from n = 1 to 5
n = symbols('n')
print(summation(1/n**2, (n, 1, 5)))  Didukung oleh

5269/3600Didukung oleh

Menyelesaikan persamaan

SymPy memudahkan penyelesaian persamaan simbolik — tidak hanya yang aljabar sederhana, tetapi juga sistem persamaan, persamaan diferensial, dan bahkan persamaan Diofantin, yang hanya memiliki bilangan bulat sebagai solusi. 

Ia memiliki pemecah (solver) bertenaga seperti 

• solve() untuk persamaan aljabar, 

• linsolve() untuk sistem linear, dan 

• dsolve() untuk persamaan diferensial yang memberikan solusi tepat bila memungkinkan. 

Persamaan aljabar

from sympy import Eq, solve
# Define and solve the equation x^2 - 4 = 0 symbolically
eq = Eq(x**2 - 4, 0)

print(solve(eq, x)) Didukung oleh

[-2, 2]Didukung oleh

Sistem persamaan

from sympy import linsolve, symbols

# Solve a system of linear equations:
# x + y = 5  and  x - y = 1
x, y = symbols('x y')
sol = linsolve([x + y - 5, x - y - 1], (x, y))

print(sol) # Outputs the solution as a set (x, y)Didukung oleh

{(3, 2)}Didukung oleh

Persamaan diferensial

from sympy import Function, dsolve

# Define y as a symbolic function of x
y = Function('y')

# Define a second-order differential equation
diff_eq = Eq(y(x).diff(x, 2) - y(x), 0)

# Solve the differential equation symbolically
print(dsolve(diff_eq))Didukung oleh

Eq(y(x), C1*exp(-x) + C2*exp(x))Didukung oleh

Operasi matriks

SymPy adalah alat yang hebat untuk aljabar linear karena mendukung matriks simbolik. Anda dapat dengan mudah bekerja dengan matriks dan melakukan operasi matematika seperti penjumlahan dan perkalian, seperti dalam aljabar biasa. 

from sympy import Matrix

# Define symbolic matrices A and B
A = Matrix([[1, 2], [x, 3]])
B = Matrix([[x], [4]])

# Perform matrix multiplication
print(A * B)Didukung oleh

Matrix([[x + 8], [x**2 + 12]])Didukung oleh

Operasi lanjutan

SymPy juga memungkinkan Anda menghitung sifat penting matriks seperti determinan, invers, nilai eigen, dan vektor eigen secara simbolik, memberikan jawaban yang tepat. 

# Compute the determinant of matrix A
A.det()      

# Compute the inverse of matrix A
A.inv()      

# Compute the eigenvalues of matrix A
A.eigenvals() Didukung oleh

{2 - sqrt(2*x + 1): 1, sqrt(2*x + 1) + 2: 1}Didukung oleh

Kemampuan pemetaan (plotting)

SymPy tidak terbatas pada komputasi simbolik — ia juga mendukung visualisasi ekspresi matematika. Menggunakan utilitas plotting bawaan, Anda dapat membuat plot 2D dan bahkan 3D dari fungsi simbolik dengan beberapa baris kode. 

Sebagai contoh, kode di bawah menghasilkan plot 2D:  

from sympy.plotting import plot


# Plot the function x^2 over the range -5 to 5
plot(x**2, (x, -5, 5))Didukung oleh

Plot 2D yang dihasilkan menggunakan SymPy. 

Untuk menghasilkan plot 3D, Anda dapat menggunakan fungsi plot3d() seperti di bawah ini.

from sympy.plotting import plot3d
from sympy import sin

# Generate a 3D surface plot of the function sin(x*y) over the specified x and y ranges
plot3d(sin(x*y), (x, -5, 5), (y, -5, 5))Didukung oleh

Kemampuan Plot 3D SymPy

Dan jika Anda memerlukan kontrol atau gaya lebih lanjut, SymPy juga dapat terintegrasi dengan Matplotlib untuk memungkinan visualisasi yang sepenuhnya dapat dikustomisasi. Untuk visualisasi yang lebih canggih, baca tutorial kami tentang Plotly Shapes.

Kemampuan Lanjutan

SymPy jauh melampaui aljabar dasar — ia meluas ke polinomial, kombinatorika, dan bahkan fisika.

Manipulasi polinomial

Anda dapat mendefinisikan dan memanipulasi polinomial dengan mudah. Kode di bawah membuat objek polinomial dari ekspresi; lalu mencetak derajatnya, bentuk terfaktornya beserta koefisien menggunakan fungsi Poly() SymPy. 

from sympy import Poly

# Create a symbolic polynomial in variable x
p = Poly(x**3 - 3*x**2 + x - 3, x)

# Print the degree of the polynomial (highest power of x)
print(p.degree())  

# Print the factorized form of the polynomial along with coefficients
print(p.factor_list())  Didukung oleh

3
(1, [(Poly(x - 3, x, domain='ZZ'), 1), (Poly(x**2 + 1, x, domain='ZZ'), 1)])Didukung oleh

Untuk sistem polinomial kompleks, basis Gröbner didukung, yang merupakan versi yang disederhanakan dan distandardisasi dari sistem persamaan polinomial, membuatnya lebih mudah diselesaikan. 

Sebagai contoh, kode di bawah menghitung basis Gröbner untuk sistem polinomial [x*y - 1, y - x], yang berarti ia menulis ulang persamaan menjadi bentuk yang lebih sederhana dan terstruktur sehingga lebih mudah diselesaikan. Keluaran menunjukkan bahwa sistem setara dengan persamaan yang lebih bersih x = y dan y² = 1, yang sekarang dapat diselesaikan langsung.

from sympy import groebner, symbols

# Define x and y as symbolic variables
x, y = symbols('x y')

# Compute the Gröbner basis for the system of polynomial equations
print(groebner([x*y - 1, y - x], x, y))Didukung oleh

GroebnerBasis([x - y, y**2 - 1], x, y, domain='ZZ', order='lex')Didukung oleh

Kombinatorika, matematika diskret, dan teori bilangan

SymPy memiliki sejumlah utilitas yang memungkinkannya menangani masalah kombinatorial dan teori bilangan. 

Sebagai contoh, pada kode di bawah:

• Fungsi binomial(5, 2) menghitung banyaknya cara memilih 2 item dari 5 (masalah kombinasi), 

• factorial(6) menghitung 6!, operasi umum dalam permutasi. 

• isprime(19) memeriksa apakah 19 adalah bilangan prima, dan 

• factorint(100) mengembalikan faktorisasi primanya yang tepat sebagai {2: 2, 5: 2}. 

from sympy import binomial, factorial, isprime, factorint
print(binomial(5, 2))   # 10
print(factorial(6))     # 720
print(isprime(19))      # True
print(factorint(100))   # {2: 2, 5: 2}Didukung oleh

10
720
True
{2: 2, 5: 2}Didukung oleh

10
720
True
{2: 2, 5: 2}Didukung oleh

Secara keseluruhan, fungsi-fungsi ini mengilustrasikan bagaimana SymPy menangani matematika diskret dengan mudah dan akurat. Anda juga dapat bekerja langsung dengan partisi, permutasi, dan kombinasi.

Aplikasi geometri dan fisika

SymPy tidak hanya untuk aljabar dan kalkulus; ia juga menawarkan modul khusus untuk geometri dan fisika. 

Dalam modul geometri, Anda dapat mendefinisikan objek matematika seperti titik, garis, lingkaran, dan poligon. Menggunakan simbol, Anda juga dapat memperoleh persamaan garis, titik potong, jarak, dan titik tengah. 

Sebagai contoh, untuk membuat dua titik dan menggambar garis di antara keduanya, lakukan saja ini:

from sympy import Point, Line, Circle

# Define two points and create a line passing through them
A, B = Point(0, 0), Point(1, 1)
L = Line(A, B)

# Print the symbolic equation of the line
print(L.equation())  Didukung oleh

-x + yDidukung oleh

Selain kemampuan geometri, SymPy menyediakan modul fisika yang sangat berguna. Dengan modul ini, Anda dapat memodelkan mekanika klasik, sistem kuantum, satuan, dan besaran.  Baik saat Anda menggunakan meter per detik untuk mencari kecepatan atau menyelesaikan persamaan gerak dengan simbol. 

from sympy.physics.units import meter, second

# Define a symbolic physical quantity: velocity = 10 meters per second
velocity = 10 * meter / second
print(velocity)Didukung oleh

10*meter/secondDidukung oleh

Pencetakan dan keluaran LaTeX

SymPy memungkinkan Anda mencetak ekspresi simbolik dalam berbagai format, termasuk:

• Pencetakan rapi yang ramah manusia 
• Keluaran berbasis Unicode, dan 
• LaTeX, yang merupakan bahasa pemformatan standar yang digunakan dalam makalah riset dan dokumentasi ilmiah. 

Anda dapat menggunakan fungsi seperti pprint() untuk membuat persamaan Anda terlihat rapi dan profesional di Jupyter notebook atau saat membuat laporan. Anda bahkan dapat menggunakan latex() untuk menyiapkannya bagi makalah riset. Ini menghemat usaha Anda untuk memformat semuanya sendiri.

from sympy import pprint, latex, symbols

# Define x and y as symbolic variables
x, y = symbols('x y')

# Now you can perform symbolic math operations
expr = (x+y)**3

# Pretty print to the console
pprint(expr)

# Print the LaTeX string
print(latex(expr))Didukung oleh

     3
(x + y) 
\left(x + y\right)^{3}Didukung oleh

Pembangkitan Kode dan Optimasi Kinerja

Meski SymPy unggul dalam komputasi simbolik, ia juga memungkinkan Anda mengonversi ekspresi simbolik menjadi kode eksekusi yang dioptimalkan untuk penggunaan numerik berkinerja tinggi.

Kode di bawah menggunakan utilitas codegen() SymPy untuk secara otomatis menghasilkan kode bahasa C dari ekspresi simbolik, sehingga siap digunakan pada aplikasi embedded.

from sympy.utilities.codegen import codegen

# Generate C code for the symbolic function and save it as 'output'
codegen(("f", x**2 + 1), "C", "output")Didukung oleh

[('output.c',
  '/******************************************************************************\n *                      Code generated with SymPy 1.14.0                      *\n *                                                                            *\n *              See http://www.sympy.org/ for more information.               *\n *                                                                            *\n *                       This file is part of \'project\'                       *\n ******************************************************************************/\n#include "output.h"\n#include <math.h>\n\ndouble f(double x) {\n\n   double f_result;\n   f_result = pow(x, 2) + 1;\n   return f_result;\n\n}\n'),
 ('output.h',
  "/******************************************************************************\n *                      Code generated with SymPy 1.14.0                      *\n *                                                                            *\n *              See http://www.sympy.org/ for more information.               *\n *                                                                            *\n *                       This file is part of 'project'                       *\n ******************************************************************************/\n\n\n#ifndef PROJECT__OUTPUT__H\n#define PROJECT__OUTPUT__H\n\ndouble f(double x);\n\n#endif\n\n")]Didukung oleh

Lambdify

Fungsi lambdify() mengonversi ekspresi simbolik menjadi fungsi Python numerik yang cepat. Sebagai contoh, kode di bawah menggunakan lambdify untuk mengonversi ekspresi simbolik yang disimpan pada objek f menjadi fungsi Python kompatibel NumPy yang cepat. Saat dievaluasi pada array [1, 2, 3], fungsi mengembalikan [4, 9, 16]. 

from sympy import lambdify
import numpy as np

# Convert the symbolic expression into a fast numerical function using NumPy
f = lambdify(x, x**2 + 2*x + 1, 'numpy')

# Evaluate the function on a NumPy array
print(f(np.array([1, 2, 3])))Didukung oleh

[ 4  9 16]Didukung oleh

Pertimbangan kinerja

Karena SymPy mengutamakan ketepatan simbolik, ia bisa lebih lambat daripada komputasi numerik. Namun demikian, ada sejumlah cara untuk meningkatkan kinerja saat bekerja dengan ekspresi yang besar atau rumit. 

Sebagai contoh, Anda dapat menggunakan lambdify() untuk mengubah ekspresi simbolik menjadi fungsi numerik cepat yang bekerja baik dengan NumPy, atau Anda dapat menyederhanakannya sebelum mengevaluasinya. 

Anda dapat mempercepat komputasi berat lebih jauh dengan menggunakan teknik seperti eliminasi subekspresi umum, kompilasi kode otomatis, dan integrasi dengan alat luar seperti Numba atau Cython.

SymPy di Ekosistem Python

SymPy tidak bekerja secara terisolasi — ia terintegrasi baik dengan alat populer lain yang digunakan dalam ilmu data, pendidikan, dan riset serta pas dengan ekosistem Python ilmiah yang lebih luas.

Integrasi dengan pustaka lain

Anda dapat mengombinasikan SymPy dengan:

• NumPy/SciPy untuk numerik berkinerja tinggi
• Matplotlib untuk visualisasi
• Pandas untuk analisis data simbolik

import numpy as np
from sympy import lambdify

# Convert the symbolic expression x^2 into a fast NumPy-compatible function
f = lambdify(x, x**2, 'numpy')

# Evaluate the function on a NumPy array from 0 to 4
print(f(np.arange(5)))Didukung oleh

[ 0  1  4  9 16]Didukung oleh

Aplikasi pendidikan

SymPy banyak digunakan di ruang kelas dan lingkungan belajar mandiri karena meniru cara matematika diajarkan di atas kertas — langkah demi langkah dan secara simbolik. Di Jupyter Notebook, siswa dapat bereksperimen langsung dengan aljabar, kalkulus, atau persamaan fisika dan melihat hasil simbolik yang tepat alih-alih pendekatan kasar. Lihat Jupyter Notebook Cheat Sheet untuk memulai.

Proyek terkait dan integrasi

SymPy juga terhubung baik dengan alat matematika bertenaga lainnya, seperti:

• SageMath — sistem matematika skala besar yang menggunakan SymPy sebagai backend.
• SymEngine — reimplementasi inti SymPy dalam C++ yang lebih cepat.
• Pyomo — mengintegrasikan pemodelan optimasi (lihat Optimizing with Pyomo).

Komunitas, Kontribusi, dan Pengembangan

SymPy berkembang berkat komunitas open source yang kuat. Sekelompok pengembang, peneliti, pengajar, dan siswa di seluruh dunia bekerja pada SymPy, menjadikannya lebih baik dan tangguh dari hari ke hari. Siapa pun dapat membantu, bertanya, atau terlibat tanpa memerlukan izin atau keanggotaan korporat.

Kontribusi dan pengembangan

Mereka yang ingin membantu biasanya melakukan fork repositori, membuat perubahan, menjalankan rangkaian uji dengan pytest, lalu mengirim pull request untuk ditinjau.

Untuk memastikan setiap perubahan andal, perubahan tersebut melalui proses tinjauan kode. Proyek ini juga memiliki kerangka pengujian sehingga kontributor dapat menjalankan tes di mesin mereka sebelum mengirimkan. 

Melaporkan bug dan mencari dukungan

Untuk bug atau bantuan:

• Buat isu di GitHub di bawah SymPy Issues
• Tanya di Stack Overflow 
• Bergabunglah dengan Gitter atau milis SymPy

Semakin jelas Anda menjelaskan masalahnya, termasuk kode, apa yang Anda harapkan terjadi, apa yang sebenarnya terjadi, dan versi SymPy yang Anda gunakan, semakin cepat komunitas dapat membantu. 

Arah pengembangan ke depan

SymPy masih terus berkembang, dengan upaya berkelanjutan untuk memperluas fiturnya, meningkatkan kinerja, dan berintegrasi dengan alat AI. Ada juga upaya untuk membuat pembangkitan kode, dokumentasi, dan penggunaan pendidikan menjadi lebih baik. Kontributor baru sangat disambut untuk membantu memilah bug dan isu, memperbaiki dokumentasi, dan menambahkan fitur baru untuk matematika simbolik.

Kesimpulan

SymPy adalah pustaka bertenaga yang memungkinkan Anda menggunakan matematika simbolik di Python. Ini membuatnya berguna untuk pendidikan, riset, dan bahkan pekerjaan rekayasa di dunia nyata. Ia menyediakan ekosistem open-source, di mana Anda dapat melakukan berbagai operasi dan transformasi matematika serta aljabar. SymPy adalah alat yang patut dipertimbangkan oleh siswa, pengembang, dan peneliti. Maka silakan — buka Jupyter notebook, impor sympy, dan mulai bereksplorasi. 

Anda juga dapat merujuk ke sumber berikut untuk bacaan lebih lanjut:

• SciPy Cheat Sheet: Linear Algebra in Python
• Dokumentasi SymPy
• Cara Melakukan Kuadrat pada Angka di Python