1. Symbolic Computation Basics
Creating symbols and expressions:
```python
from sympy import symbols, Symbol
x, y, z = symbols('x y z')
expr = x*2 + 2x + 1
# With assumptions
x = symbols('x', real=True, positive=True)
n = symbols('n', integer=True)
```
Simplification and manipulation:
```python
from sympy import simplify, expand, factor, cancel
simplify(sin(x)2 + cos(x)2) # Returns 1
expand((x + 1)3) # x3 + 3x2 + 3x + 1
factor(x*2 - 1) # (x - 1)(x + 1)
```
For detailed basics: See references/core-capabilities.md
2. Calculus
Derivatives:
```python
from sympy import diff
diff(x*2, x) # 2x
diff(x*4, x, 3) # 24x (third derivative)
diff(x*2y*3, x, y) # 6xy*2 (partial derivatives)
```
Integrals:
```python
from sympy import integrate, oo
integrate(x2, x) # x3/3 (indefinite)
integrate(x**2, (x, 0, 1)) # 1/3 (definite)
integrate(exp(-x), (x, 0, oo)) # 1 (improper)
```
Limits and Series:
```python
from sympy import limit, series
limit(sin(x)/x, x, 0) # 1
series(exp(x), x, 0, 6) # 1 + x + x2/2 + x3/6 + x4/24 + x5/120 + O(x**6)
```
For detailed calculus operations: See references/core-capabilities.md
3. Equation Solving
Algebraic equations:
```python
from sympy import solveset, solve, Eq
solveset(x**2 - 4, x) # {-2, 2}
solve(Eq(x**2, 4), x) # [-2, 2]
```
Systems of equations:
```python
from sympy import linsolve, nonlinsolve
linsolve([x + y - 2, x - y], x, y) # {(1, 1)} (linear)
nonlinsolve([x2 + y - 2, x + y2 - 3], x, y) # (nonlinear)
```
Differential equations:
```python
from sympy import Function, dsolve, Derivative
f = symbols('f', cls=Function)
dsolve(Derivative(f(x), x) - f(x), f(x)) # Eq(f(x), C1*exp(x))
```
For detailed solving methods: See references/core-capabilities.md
4. Matrices and Linear Algebra
Matrix creation and operations:
```python
from sympy import Matrix, eye, zeros
M = Matrix([[1, 2], [3, 4]])
M_inv = M**-1 # Inverse
M.det() # Determinant
M.T # Transpose
```
Eigenvalues and eigenvectors:
```python
eigenvals = M.eigenvals() # {eigenvalue: multiplicity}
eigenvects = M.eigenvects() # [(eigenval, mult, [eigenvectors])]
P, D = M.diagonalize() # M = PDP^-1
```
Solving linear systems:
```python
A = Matrix([[1, 2], [3, 4]])
b = Matrix([5, 6])
x = A.solve(b) # Solve Ax = b
```
For comprehensive linear algebra: See references/matrices-linear-algebra.md
5. Physics and Mechanics
Classical mechanics:
```python
from sympy.physics.mechanics import dynamicsymbols, LagrangesMethod
from sympy import symbols
# Define system
q = dynamicsymbols('q')
m, g, l = symbols('m g l')
# Lagrangian (T - V)
L = m(lq.diff())*2/2 - mgl(1 - cos(q))
# Apply Lagrange's method
LM = LagrangesMethod(L, [q])
```
Vector analysis:
```python
from sympy.physics.vector import ReferenceFrame, dot, cross
N = ReferenceFrame('N')
v1 = 3N.x + 4N.y
v2 = 1N.x + 2N.z
dot(v1, v2) # Dot product
cross(v1, v2) # Cross product
```
Quantum mechanics:
```python
from sympy.physics.quantum import Ket, Bra, Commutator
psi = Ket('psi')
A = Operator('A')
comm = Commutator(A, B).doit()
```
For detailed physics capabilities: See references/physics-mechanics.md
6. Advanced Mathematics
The skill includes comprehensive support for:
- Geometry: 2D/3D analytic geometry, points, lines, circles, polygons, transformations
- Number Theory: Primes, factorization, GCD/LCM, modular arithmetic, Diophantine equations
- Combinatorics: Permutations, combinations, partitions, group theory
- Logic and Sets: Boolean logic, set theory, finite and infinite sets
- Statistics: Probability distributions, random variables, expectation, variance
- Special Functions: Gamma, Bessel, orthogonal polynomials, hypergeometric functions
- Polynomials: Polynomial algebra, roots, factorization, Groebner bases
For detailed advanced topics: See references/advanced-topics.md
7. Code Generation and Output
Convert to executable functions:
```python
from sympy import lambdify
import numpy as np
expr = x*2 + 2x + 1
f = lambdify(x, expr, 'numpy') # Create NumPy function
x_vals = np.linspace(0, 10, 100)
y_vals = f(x_vals) # Fast numerical evaluation
```
Generate C/Fortran code:
```python
from sympy.utilities.codegen import codegen
[(c_name, c_code), (h_name, h_header)] = codegen(
('my_func', expr), 'C'
)
```
LaTeX output:
```python
from sympy import latex
latex_str = latex(expr) # Convert to LaTeX for documents
```
For comprehensive code generation: See references/code-generation-printing.md
|