complex-mathematics

Many complex math features.


License
MIT
Install
pip install complex-mathematics==4.17.10

Documentation

complex_mathematics

Version


complex_mathematics is a Python module that can be used for many complex math related problems, with concepts from many different topics in mathematics, such as calculus, linear algebra, geometry, algebra, statistics, and more. It also has machine learning algorithms such as linear regression and K-Nearest-Neighbors.


To get started:

Install with:

pip install complex_mathematics


Linear Algebra:

from complex_mathematics.linalg import BLANK

Eigenvectors:

The eigenvector class has one parameter, the matrix

The eigenvalues attribute holds the eigenvalues

The eigenvectors attribute holds the eigenvectors

from complex_mathematics.linalg import eigenvector
import numpy as np

mat = np.array([[1, 0, 0], [0, 2, 0], [0, 0, 3]])

eig = eigenvector(mat) #eigenvector(matrix)

print(eig.eigenvalues)
print(eig.eigenvectors)

Matrix Inverse:

The matrix inverse function has one parameter, the matrix

It returns the inverse

from complex_mathematics.linalg import inverse
import numpy as np

matrix = np.array([[1, 2], [3, 4]])

inv = inverse(matrix)

print(inv)

Machine Learning:

from complex_mathematics.ml import BLANK

Linear Regression:

The LinearRegression class has four parameters, the learning rate with a default 0.01, the max iterations with a default 10000, the tolerance, and optimization method with a default of batch gradient descent

Batch Gradient Descent:

import numpy as np
import random
from complex_mathematics.ml import LinearRegression


X = np.array([[i] for i in range(-50, 51)])
y = np.array([2*i + 1 + random.uniform(-1, 1) for i in range(-50, 51)])

model = LinearRegression(learning_rate = 0.00001)

model.fit(X, y)

print(model.predict(np.array([10])))

Normal Equations:

import numpy as np
import random
from complex_mathematics.ml import LinearRegression
    

X = np.array([i for i in range(-50, 51)])
y = np.array([2*i + 1 + random.uniform(-1, 1) for i in range(-50, 51)])

model = LinearRegression(optimization_method = "NormalEquations")

model.fit(X, y)

print(model.predict(np.array([10])))

K-Means Clustering:

The KMeans class has four parameters, the dataset, the number of centroids(k), the max iterations, with a default of 100, and the tolerance, with a default of 10^-4

from complex_mathematics.ml import KMeans
import numpy as np

data = np.array([
    [2, 3, 4],
    [3, 5, 6],
    [4, 4, 5],
    [2, 6, 3],
    [7, 2, 1],
    [6, 4, 2],
    [8, 5, 4],
    [9, 4, 3]
])

model = KMeans(data, 6) #KMeans(data, k, max_iters=100, tolerance=1e-4)

print(model.centroids, model.labels)

Tokenizer:

The tokenizer function has two parameters, the string that will be tokenized, and the delimiter, with a default of " "

from complex_mathematics.ml import tokenizer

print(tokenizer("This should have 5 tokens")) #tokenizer(string, delimiter = " ")

Logarithmic Regression:

Logarithmic regression fits a logarithmic line to data, of the form f(x) = a*ln(x)+b

Unfortunately, for now, the class only takes in two dimensional lists, so for those of you wanting to use numpy arrays and multi-dimensional datasets, sorry

It takes in two parameters, the x values and the y values

from complex_mathematics.ml import LogarithmicRegression


X = [2, 3, 4, 5, 6]
y = [0.117, 0.152, 0.193, 0.232, 0.266]

model = LogarithmicRegression(X, y)
print(model.a, model.b)

Polynomial Regression:

Polynomial regression fits an n degree polynomial function

The PolynomialRegression class has three parameters, the degree, the learning rate with a default 0.001, and the max iterations with a default 10000

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from complex_mathematics.ml import PolynomialRegression

np.random.seed(0)
X = np.random.rand(80, 2)
y = np.sum(X, axis=1) + np.random.normal(0, 0.1, X.shape[0])

poly_reg = PolynomialRegression(degree=2)

poly_reg.fit(X, y)

x1_test = np.linspace(0, 1, 20)
x2_test = np.linspace(0, 1, 20)
X1_test, X2_test = np.meshgrid(x1_test, x2_test)
X_test = np.column_stack((X1_test.ravel(), X2_test.ravel()))

y_pred = poly_reg.predict(X_test)

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
scatter = ax.scatter(X[:, 0], X[:, 1], y, c='gray', label='Actual Data')

surface = ax.plot_surface(X1_test, X2_test, y_pred.reshape(X1_test.shape), color='red', alpha=0.5, label='Polynomial Regression')

ax.set_xlabel('Feature 1')
ax.set_ylabel('Feature 2')
ax.set_zlabel('Target')

plt.show()

Algebra:

from complex_mathematics.algebra import BLANK

Quadratic Equation Solver:

The quadratic function has one parameter, the equation in string form

It returns the solutions in a numpy array

from complex_mathematics.algebra import quadratic

print(quadratic("-x^2-x+12"))

Polynomial Solver:

The polynomial solver has one parameter, a numpy array of the coefficients of the equation

It returns the solutions in a numpy array

import numpy as np
from complex_mathematics.algebra import solve

coefs = np.array([1, 0, -16])

print(solve(coefs)) #solve(coefs, step=0.01, tolerance=1e-8, srange=100)

Natural Log:

The natural log function takes in one parameter, the number

from complex_mathematics.algebra import ln

print(ln(15))

E to the x power:

The exp() function takes in one parameter, the number

from complex_mathematics.algebra import exp

print(exp(3))

Common Logarithm:

The log() function takes in one parameter, the number

from complex_mathematics.algebra import log

print(log(3))

Parametric Equation Grapher:

The parametric_graph() function takes in 4 parameters, the x function, the y function, the t minimum, and the t maximum.

from complex_mathematics.algebra import parametric_graph
import numpy as np

def x(t):
  return ((np.cos(t))**3)*(5*(np.sin(t))**2-(np.cos(t))**2)

def y(t):
  return ((np.sin(t))**3)*(5*(np.cos(t))**2-(np.sin(t))**2)

parametric_graph(x, y, 0, 6.28)

Statistics:

from complex_mathematics.stats import BLANK

Percent Change:

The percent change function has two parameters, the previous value and the new value

It returns the percent change

from complex_mathematics.stats import pchange

print(pchange(100, 110)) #pchange(a, b)

Mean:

The mean function has one parameter, the data

It returns the mean of the data

import numpy as np
from complex_mathematics.stats import mean

a = np.array([5, 15, 20, 25])

print(mean(a)) #mean(data)

Median:

The median function has one parameter, the data

It returns the median of the data

import numpy as np
from complex_mathematics.stats import median

a = np.array([5, 15, 20, 25])

print(median(a)) #median(data)

Standard Deviation:

The standard deviation function has one parameter, the data

It returns the standard deviation of the data

import numpy as np
from complex_mathematics.stats import sd

print(sd(np.array([1, 2, 4, 8, 16]))) #sd(data)

Factors:

The factor function has one parameter, the number that is to be factored

It returns a numpy array of the factors of that number

It includes negative factors

from complex_mathematics.stats import factor

print(factor(80))

Gaussian Calculator:

The gaussian function takes in one parameter, the data, and gives you function that calculates the probability of a number appearing based on the frequency of numbers in the data.

from complex_mathematics.stats import gaussian
import numpy as np
import matplotlib.pyplot as plt


data = np.array([1, 2, 2, 3, 3, 3, 4, 4, 5])

p = gaussian(data)

x = np.arange(0, 6, 0.1) 

y = np.apply_along_axis(p, 0, x)

plt.plot(x, y)

plt.show()

Complex Numbers:

from complex_mathematics.complex import BLANK

Complex Number:

The complex number class has two parameters, the real part and the imaginary part

It has three functions: mod(), which gives the modulus of the number; arg(), which gives the argument of the number; and conjugate(), which gives the conjugate of the number.

from complex_mathematics.complex import complex

num = complex(4, 6)

print(num.mod())
print(num.arg())
print(num.conjugate())

Complex Multiplication:

The complex multiplication function has two parameters, the two complex numbers that will be multiplied.

from complex_mathematics.complex import complex
from complex_mathematics.complex import cmultiply

num1 = complex(4, 6)
num2 = complex(1, 2)

res = cmultiply(num1, num2)

print(res.a, res.bi)

License

Distributed under the MIT License. See LICENSE for more information.