AVLGMath - Advanced Vector & Linear Algebra / Numerical Methods Library

A high-performance Python library for advanced linear algebra, numerical interpolation, numerical integration, matrix operations, and linear system solving. Optimized for numerical computing with NumPy BLAS/LAPACK backends.

Installation

pip install avlgmath

Features

Interpolation Methods: Newton Forward/Backward Difference, Lagrangian
Numerical Integration: Trapezoidal Rule, Simpson's 1/3 Rule with error estimation
Linear Algebra: Matrix operations, eigenvalues, eigenvectors, rank computation
Linear System Solving: Jacobi iteration method
Vector Analysis: Dependence checking
Differential Equations: First-order linear ODE solver
Taylor Series: Taylor theorem expansions for 1 and 2 variables

Quick Start

import numpy as np
from avlgmath import *

# Newton Forward Difference Interpolation
X = np.array([0, 1, 2, 3])
Y = np.array([1, 3, 7, 13])
table = nfd(X, Y)
y_interp = nfd_interpolate(X, Y, 1.5)

# Matrix Operations
A = np.array([[1, 2], [3, 4]])
eigenvalues = eigenval(A)

# Jacobi Iteration
A = np.array([[4, -1], [-1, 3]])
b = np.array([7, 5])
result = jacobi_iter(A, b, n=20)

Function Reference

Interpolation Functions

`nfd(X, Y)`

Newton Forward Difference Table - Creates difference table for equally spaced points

Parameter	Type	Description
X	numpy array	x-coordinates (equally spaced)
Y	numpy array	y-coordinates
Returns	numpy array	2D array of differences

X = np.array([0, 1, 2, 3, 4])
Y = np.array([1, 2, 5, 10, 17])
table = nfd(X, Y)

`nfd_interpolate(X, Y, x)`

Newton Forward Difference Interpolation - Interpolates value at point x

Parameter	Type	Description
X	numpy array	x-coordinates (equally spaced)
Y	numpy array	y-coordinates
x	float	Point at which to interpolate
Returns	float	Interpolated value

X = np.array([0, 1, 2, 3])
Y = np.array([1, 2, 5, 10])
y_at_1_5 = nfd_interpolate(X, Y, 1.5)  # ≈ 3.375

`nfdfrom_csv(path)`

Load Newton forward difference from CSV file

Parameter	Type	Description
path	str	Path to CSV file with columns 'x' and 'y'
Returns	numpy array	Difference table

`nbd(X, Y)`

Newton Backward Difference Table - Creates difference table from end points

Parameter	Type	Description
X	numpy array	x-coordinates (equally spaced)
Y	numpy array	y-coordinates
Returns	numpy array	2D array of differences

`nbd_interpolate(X, Y, x)`

Newton Backward Difference Interpolation - Interpolates using backward differences

Parameter	Type	Description
X	numpy array	x-coordinates (equally spaced)
Y	numpy array	y-coordinates
x	float	Point at which to interpolate
Returns	float	Interpolated value

`nbdfrom_csv(path)`

Load Newton backward difference from CSV file

Parameter	Type	Description
path	str	Path to CSV file with columns 'x' and 'y'
Returns	numpy array	Difference table

`lagrangian(X, Y)`

Lagrangian Interpolation - Creates interpolating polynomial through all points

Parameter	Type	Description
X	numpy array	x-coordinates (must be distinct)
Y	numpy array	y-coordinates
Returns	dict	Contains polynomial object and evaluation function

X = np.array([1, 2, 3])
Y = np.array([2, 3, 5])
result = lagrangian(X, Y)
y_at_1_5 = result['evaluate'](1.5)

Numerical Integration Functions

`ploytrap(coefficients, a, b, n=100)`

Polynomial Trapezoidal Rule - Integrates polynomial using trapezoidal method

Parameter	Type	Description
coefficients	list/array	Polynomial coefficients [c₀, c₁, c₂, ...]
a	float	Lower limit of integration
b	float	Upper limit of integration
n	int	Number of subintervals (default 100)
Returns	float	Estimated integral value

coeffs = [1, 2, 1]  # 1 + 2x + x²
result = ploytrap(coeffs, a=0, b=3, n=100)

`polytrap_e(coefficients, a, b, n=100)`

Trapezoidal Rule Error Estimation

Parameter	Type	Description
coefficients	list/array	Polynomial coefficients
a	float	Lower limit
b	float	Upper limit
n	int	Number of subintervals
Returns	dict	Error bound and max second derivative

`polysim(coefficients, a, b, n=100)`

Polynomial Simpson's 1/3 Rule - More accurate than trapezoidal

Parameter	Type	Description
coefficients	list/array	Polynomial coefficients
a	float	Lower limit of integration
b	float	Upper limit of integration
n	int	Number of subintervals (must be even)
Returns	float	Estimated integral value

`polysim_e(coefficients, a, b, n=100)`

Simpson's 1/3 Rule Error Estimation

Parameter	Type	Description
coefficients	list/array	Polynomial coefficients
a	float	Lower limit
b	float	Upper limit
n	int	Number of subintervals (must be even)
Returns	dict	Error bound and max fourth derivative

Matrix Operations

`matrixmul(A, B)`

Efficient Matrix Multiplication - BLAS-optimized

Parameter	Type	Description
A	numpy array	First matrix (m × n)
B	numpy array	Second matrix (n × p)
Returns	numpy array	Result matrix (m × p)

`diagonalmul(A, diagonal=None)`

Diagonal Matrix Multiplication - O(mn) instead of O(mn²)

Parameter	Type	Description
A	numpy array	2D matrix
diagonal	array/scalar	Diagonal elements (None = extract from A)
Returns	dict	Result matrix and operation details

`rankm(A)`

Matrix Rank - Using efficient SVD method

Parameter	Type	Description
A	numpy array	Any 2D matrix
Returns	int	Rank of the matrix

`eigenval(A)`

Eigenvalues - For square or singular values for rectangular matrices

Parameter	Type	Description
A	numpy array	Any 2D matrix
Returns	dict	Type and values

A = np.array([[1, 2], [3, 4]])
result = eigenval(A)
# {'type': 'eigenvalues', 'values': array([5.372, -0.372])}

`eigenvec(A)`

Eigenvectors - Unique, normalized eigenvectors or singular vectors

Parameter	Type	Description
A	numpy array	Any 2D matrix
Returns	dict	Eigenvectors with eigenvalues

Linear System Solving

`jacobi_iter(A, b, n=10, x0=None, tolerance=1e-6)`

Jacobi Iteration - Solves Ax = b using iterative method

Parameter	Type	Description
A	numpy array	Coefficient matrix (n × n, square)
b	numpy array	Constants vector
n	int	Maximum iterations
x0	array	Initial guess (default zero vector)
tolerance	float	Convergence tolerance
Returns	dict	Solution, convergence history, residual

A = np.array([[4, -1], [-1, 3]], dtype=float)
b = np.array([7, 5], dtype=float)
result = jacobi_iter(A, b, n=20, tolerance=1e-6)
print(result['solution'])  # [2., 1.]
print(result['converged'])  # True

Vector Analysis

`depvec(vectors)`

Dependent Vectors - Check linear dependence/independence

Parameter	Type	Description
vectors	numpy array	2D array where each row is a vector
Returns	dict	Dependent flag (1=dependent, 0=independent)

v = np.array([[1, 0], [0, 1]])
result = depvec(v)
# {'dependent': 0, 'rank': 2, 'explanation': 'Linearly independent'}

Differential Equations

`Lde(p_coeffs, q_coeffs, y0=0)`

Linear Differential Equation Solver - Solves dy/dx + p(x)y = q(x)

Parameter	Type	Description
p_coeffs	list/array	Coefficients of p(x) polynomial
q_coeffs	list/array	Coefficients of q(x) polynomial
y0	float	Initial condition y(0)
Returns	dict	Particular and general solutions

p_coeffs = [0, 2]  # 0 + 2x
q_coeffs = [0, 1]  # 0 + x
result = Lde(p_coeffs, q_coeffs, y0=1)

Taylor Series Functions

`taylor_1var(f_expr, x0, n, x_eval=None)`

Taylor Series Expansion - Single Variable

Computes the Taylor polynomial of degree n for a function around point x₀.

Parameter	Type	Description
f_expr	str or sympy expr	Function expression (e.g., "sin(x)", "exp(x)")
x0	float	Center point for Taylor expansion
n	int	Degree of Taylor polynomial
x_eval	float	Optional point to evaluate Taylor approximation
Returns	dict	Symbolic series, value, error, terms

# Taylor expansion of sin(x) around x=0
result = taylor_1var("sin(x)", 0, 5)
print(result['series'])  # x**5/120 - x**3/6 + x

# Evaluate at x=0.1
result = taylor_1var("sin(x)", 0, 5, x_eval=0.1)
print(f"Approximation: {result['value']}")
print(f"Actual value: {result['actual_value']}")
print(f"Error: {result['error']}")

# Exponential function
result = taylor_1var("exp(x)", 0, 4, x_eval=0.5)

`taylor_2var(f_expr, x0, y0, n, x_eval=None, y_eval=None)`

Taylor Series Expansion - Two Variables

Computes the Taylor polynomial of degree n for a two-variable function around point (x₀, y₀).

Parameter	Type	Description
f_expr	str or sympy expr	Function of x,y (e.g., "x2 + y2", "sin(x)*cos(y)")
x0	float	Center point x-coordinate
y0	float	Center point y-coordinate
n	int	Degree of Taylor polynomial
x_eval	float	Optional x-coordinate for evaluation
y_eval	float	Optional y-coordinate for evaluation
Returns	dict	Symbolic series, partial derivatives, value, error

# Taylor expansion of x² + y² + xy around (0,0)
result = taylor_2var("x**2 + y**2 + x*y", 0, 0, 2)
print(result['series'])  # x**2 + x*y + y**2

# With evaluation
result = taylor_2var("x**2 + y**2 + x*y", 0, 0, 2, x_eval=0.1, y_eval=0.1)
print(f"Taylor value: {result['value']}")  # 0.03
print(f"Partial derivatives: {result['partial_derivatives']}")

# Two-variable trigonometric function
result = taylor_2var("sin(x)*cos(y)", 0, 0, 3, x_eval=0.2, y_eval=0.2)
print(f"Error: {result['error']}")

Requirements

numpy>=1.20
pandas>=1.3
scipy>=1.7
sympy>=1.9

Performance Notes

All functions use NumPy with BLAS/LAPACK backends
Matrix operations: O(n³) for multiplication
Interpolation: O(n) per evaluation
Jacobi iteration: O(n²) per iteration
Simpson's rule: ~100x more accurate than trapezoidal

Error Handling

Comprehensive validation included:

Dimension checks
Singular matrix detection
Invalid parameter ranges
Convergence monitoring

License

MIT License - Free to use and modify

Contact & Support

For issues, contributions, and feedback, please submit to the repository.

Citation

@software{avlgmath2026,
  title = {AVLGMath: Advanced Linear Algebra and Numerical Methods Library},
  year = {2026}
}

Name		Name	Last commit message	Last commit date
.vscode		.vscode
__pycache__		__pycache__
avlgmath.egg-info		avlgmath.egg-info
avlgmath		avlgmath
build/lib		build/lib
dist		dist
tests		tests
.DS_Store		.DS_Store
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt
setup.py		setup.py

Latest commit

History

Folders and files

Repository files navigation

AVLGMath - Advanced Vector & Linear Algebra / Numerical Methods Library

Installation

Features

Quick Start

Function Reference

Interpolation Functions

nfd(X, Y)

nfd_interpolate(X, Y, x)

nfdfrom_csv(path)

nbd(X, Y)

nbd_interpolate(X, Y, x)

nbdfrom_csv(path)

lagrangian(X, Y)

Numerical Integration Functions

ploytrap(coefficients, a, b, n=100)

polytrap_e(coefficients, a, b, n=100)

polysim(coefficients, a, b, n=100)

polysim_e(coefficients, a, b, n=100)

Matrix Operations

matrixmul(A, B)

diagonalmul(A, diagonal=None)

rankm(A)

eigenval(A)

eigenvec(A)

Linear System Solving

jacobi_iter(A, b, n=10, x0=None, tolerance=1e-6)

Vector Analysis

depvec(vectors)

Differential Equations

Lde(p_coeffs, q_coeffs, y0=0)