The SymPy library in Python

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
# An algebraic expression
expr = 4*x**2 + 2*x + 2 + 2*x + 4*x**2
# Simplify the expression
simplified_expr = sp.simplify(expr)
print("Simplified expression : ",simplified_expr)  # Output: 5*x**2 + 2*x + 1

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
# Define an expression with parentheses
expr = (x + 1)*(x - 2)
# Expand the expression
expanded_expr = sp.expand(expr)
print(expanded_expr) 

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
expr=x**2 - x - 2
# Factorize the expression
factored_expr = sp.factor(expr)
print(factored_expr)

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
 
# Define a trigonometric expression
expr = sp.sin(x)**2 + sp.cos(x)**2
# Simplify the trigonometric expression
simplified_trig_expr = sp.trigsimp(expr)
print(simplified_trig_expr)  # Output: 1

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
# Define a function
f = x**3 + 2*x**2 - 5*x + 1
# Differentiate the function with respect to x
df_dx = sp.diff(f, x)
print("Differentiated function:", df_dx)

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
# Define a function
g = sp.sin(x) + sp.exp(x)
# Integrate the function with respect to x
integrated_g = sp.integrate(g, x)
print("Integrated function:", integrated_g)

import sympy as sp
# Symbol Variables
x, y = sp.symbols('x y')
# Define a function
h = (x**2 - 1) / (x - 1)
# Calculate the limit as x approaches 1
limit_h = sp.limit(h, x, 1)
print("Limit of the function:", limit_h)

import sympy as sp
# Define symbolic variables
x, y, z = sp.symbols('x y z')
# Define a matrix
A = sp.Matrix([[1, 6, 3], [4, 5, 6], [7, 8, 9]])
# Define a vector
v = sp.Matrix([x, y, z])
# Matrix Transpose
A_transpose = A.T
print("Matrix A Transpose:")
print(A_transpose)
# Matrix Determinant
det_A = A.det()
print("Determinant of matrix A:", det_A)
# Matrix Inverse
A_inv = A.inv()
print("Inverse of matrix A:")
print(A_inv)
# Matrix Multiplication
A_times_v = A * v
print("Matrix multiplication of A and the vector v:")
print(A_times_v)

import sympy as sp
# Define symbolic variables
z = sp.Symbol('z', complex=True)
# Define two complex numbers
z1 = 3 + 4j
z2 = 1 - 2j
# Addition
z_sum = z1 + z2
print("Sum of complex numbers:", z_sum)
# Subtraction
z_diff = z1 - z2
print("Difference of complex numbers:", z_diff)
# Multiplication
z_prod = z1 * z2
print("Product of complex numbers:", z_prod)
# Division
z_div = z1 / z2
print("Division of complex numbers:", z_div)
# Complex conjugate
z_conjugate = sp.conjugate(z1)
print("Complex conjugate of z1:", z_conjugate)

import sympy as sp
# Define the symbolic variable and the function
x = sp.symbols('x')
y = sp.Function('y')(x)
# Define the differential equation
diff_eq = sp.Eq(y.diff(x, x) - 3*y.diff(x) + 2*y, sp.sin(x))
# Solve the differential equation
solution = sp.dsolve(diff_eq)
# Print the solution
print("Solution to the differential equation:")
print(solution)

import sympy as sp
# Define symbolic variables
n, k = sp.symbols('n k')
# Calculate permutations
permutations = sp.factorial(n) / sp.factorial(n - k)
print("Permutations (nPk):", permutations)
# Calculate combinations
combinations = sp.factorial(n) / (sp.factorial(k) * sp.factorial(n - k))
print("Combinations (nCk):", combinations)
import sympy as sp
# Check primality
print("Is 7 prime?", sp.isprime(7))
# Find divisors of a number
print("Divisors of 12:", sp.divisors(12))
# Compute greatest common divisor (GCD)
print("GCD of 24 and 36:", sp.gcd(24, 36))
n = 5
# n-th Bell number
bell_number = sp.bell(n)
print(f"Bell({n}) =", bell_number)  # Output: Bell(5) = 52
n = 5
# n-th Catalan number
catalan_number = sp.catalan(n)
print(f"Catalan({n}) =", catalan_number)  # Output: Catalan(5) = 42
n = 5
# n-th harmonic number
harmonic_number = sp.harmonic(n)
print(f"Harmonic({n}) =", harmonic_number)  # Output: Harmonic(5) = 137/60

import sympy as sp
# Define the variable and the function
t, s = sp.symbols('t s')
f_t = sp.exp(-t)
# Compute the Laplace Transform
laplace_f_t = sp.laplace_transform(f_t, t, s)
print("Laplace Transform of f(t):", laplace_f_t)
# Compute the Inverse Laplace Transform
inverse_laplace_f_s = sp.inverse_laplace_transform(laplace_f_t[0], s, t)
print("Inverse Laplace Transform of F(s):", inverse_laplace_f_s)
# Define the variable and the function
x, k = sp.symbols('x k')
f_x = sp.sin(x)
# Compute the Fourier Transform
fourier_f_x = sp.fourier_transform(f_x, x, k)
print("Fourier Transform of f(x):", fourier_f_x)
# Compute the Inverse Fourier Transform
inverse_fourier_f_k = sp.inverse_fourier_transform(fourier_f_x, k, x)
print("Inverse Fourier Transform of F(k):", inverse_fourier_f_k)
# Define the variable and the function
t, s = sp.symbols('t s', positive=True)
f_t = t**(-s)
# Compute the Mellin Transform
mellin_f_t = sp.mellin_transform(f_t, t, s)
print("Mellin Transform of f(t):", mellin_f_t)

import sympy as sp
# Define a finite set
A = sp.FiniteSet(1, 2, 3, 4, 5)
# Check if an element is in the set
print(1 in A)  # Output: True
print(6 in A)  # Output: False
# Define an open interval (1, 5)
I = sp.Interval(1, 5, left_open=True, right_open=True)
# Check if a number is in the interval
print(2 in I)  # Output: True
print(5 in I)  # Output: False
C = sp.FiniteSet(3, 4, 5)
# Intersection of sets A and C
intersection_AC = A.intersect(C)
print("Intersection of sets A and C:", intersection_AC)  # Output: Intersection of sets A and C: {3, 4, 5}
# Complement of set A with respect to set C
complement_A_C = C.complement(A)
print("Complement of set A with respect to set C:", complement_A_C)  # Output: Complement of set A with respect to set C: {4, 5}

import sympy as sp
# Define symbolic variables
p, q, r = sp.symbols('p q r')
# Define logical expressions
expr_and = sp.And(p, q)
expr_or = sp.Or(p, q)
expr_not = sp.Not(p)
expr_implies = sp.Implies(p, q)
expr_equivalent = sp.Equivalent(p, q)
expr_xor = sp.Xor(p, q)
expr_nand = sp.Nand(p, q)
expr_nor = sp.Nor(p, q)
# Evaluate the logical expressions
values = {p: True, q: False}
print("AND:", expr_and.subs(values))               
print("OR:", expr_or.subs(values))                
print("NOT:", expr_not.subs(values))               
print("IMPLIES:", expr_implies.subs(values))       
print("EQUIVALENT:", expr_equivalent.subs(values)) 
print("XOR:", expr_xor.subs(values))               
print("NAND:", expr_nand.subs(values))             
print("NOR:", expr_nor.subs(values))               

import sympy as sp
x, y = sp.symbols('x y')
# Define a complicated expression
expr = sp.sin(x)**2 + sp.cos(x)**2
# Simplify the expression
simplified_expr = sp.simplify(expr)
print(simplified_expr)  
# Define a complex expression
expr = sp.sqrt(8)
# Numerically simplify the expression
numerically_simplified_expr = sp.nsimplify(expr)
print(numerically_simplified_expr)  
# Define a rational expression
expr = (x**2 - 1)/(x**2 + x - 2)
# Simplify the rational expression
simplified_rational_expr = sp.ratsimp(expr)
print(simplified_rational_expr)  
# Define a rational expression
expr = (x**2 - 1)/(x**2 - y**2)
# Cancel common factors
canceled_expr = sp.cancel(expr)
print(canceled_expr)  

import sympy as sp
import sympy.stats as stats
# Define a normal distribution
x, mu, sigma = sp.symbols('x mu sigma')
normal_dist = stats.Normal('X', mu, sigma)
# Probability density function (PDF)
pdf = stats.density(normal_dist)(x)
print("Normal Distribution PDF:", pdf)
# Cumulative distribution function (CDF)
cdf = stats.cdf(normal_dist)(x)
print("Normal Distribution CDF:", cdf)

import sympy as sp
# Define symbolic variables
x, y = sp.symbols('x y')
# Define a mathematical expression
expr = x**2 + 3*x + sp.sqrt(y)
# Obtain the LaTeX representation
latex_expr = sp.latex(expr)
# Print the LaTeX representation
print(latex_expr)