stmath 1.0.0__tar.gz

stmath-1.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: stmath
+Version: 1.0.0
+Summary: A unified Math + ML + AI + Crypto + Quantum library for Python
+Author: Saksham Tomar
+Author-email: Saksham Tomar <tomarsaksham55@gmail.com>
+Keywords: math,ai,ml,deep-learning,quantum,statistics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+
+<div align="center">
+
+# ⚡ STMATH
+### The Next-Generation Unified Math + AI + ML + Quantum Engine  
+**Built for developers. Designed for performance. Powered by purity.**
+
+</div>
+
+---
+
+## 🔥 What is STMATH?
+
+STMATH is a **next-generation computational engine** that merges:
+
+- 🧮 Core Math  
+- 📐 Scientific Functions  
+- 📊 ML & DL Metrics  
+- 🤖 GEN-AI Math (Attention, Logits→Prob, Temperature Softmax)  
+- 🧭 Graph Algorithms  
+- 🔍 Vision Utils (Conv2D Output, MaxPool Shape, IoU, NMS)  
+- ⚙ Optimizers (Adam, RMSProp, Momentum, Cosine Anneal, SGD)  
+- 💹 Finance Math  
+- 🔗 Crypto Hashing  
+- ⚛ Quantum Gates  
+- ⏳ Time Series Tools  
+- 📚 Aptitude & Algebra  
+
+All in **one clean import**:
+
+```python
+
+import stmath as am

stmath-1.0.0/README.md

@@ -0,0 +1,32 @@
+<div align="center">
+
+# ⚡ STMATH
+### The Next-Generation Unified Math + AI + ML + Quantum Engine  
+**Built for developers. Designed for performance. Powered by purity.**
+
+</div>
+
+---
+
+## 🔥 What is STMATH?
+
+STMATH is a **next-generation computational engine** that merges:
+
+- 🧮 Core Math  
+- 📐 Scientific Functions  
+- 📊 ML & DL Metrics  
+- 🤖 GEN-AI Math (Attention, Logits→Prob, Temperature Softmax)  
+- 🧭 Graph Algorithms  
+- 🔍 Vision Utils (Conv2D Output, MaxPool Shape, IoU, NMS)  
+- ⚙ Optimizers (Adam, RMSProp, Momentum, Cosine Anneal, SGD)  
+- 💹 Finance Math  
+- 🔗 Crypto Hashing  
+- ⚛ Quantum Gates  
+- ⏳ Time Series Tools  
+- 📚 Aptitude & Algebra  
+
+All in **one clean import**:
+
+```python
+
+import stmath as am

stmath-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stmath"
+version = "1.0.0"
+description = "A unified Math + ML + AI + Crypto + Quantum library for Python"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name="Saksham Tomar", email="tomarsaksham55@gmail.com" }
+]
+keywords = ["math", "ai", "ml", "deep-learning", "quantum", "statistics"]
+requires-python = ">=3.8"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = []

stmath-1.0.0/setup.cfg

@@ -0,0 +1,17 @@
+[metadata]
+name = stmath
+version = 1.0.0
+license = MIT
+description = A unified Math + ML + AI + Crypto + Quantum library for Python.
+long_description = file: README.md
+long_description_content_type = text/markdown
+
+[options]
+packages = find:
+python_requires = >=3.8
+include_package_data = True
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

stmath-1.0.0/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="stmath",
+    version="1.0.0",
+    packages=find_packages(),
+    description="AI-powered universal math library",
+    author="Saksham Tomar",
+)

stmath-1.0.0/stmath/__init__.py

@@ -0,0 +1,270 @@
+"""
+AIMATHX — One-line import math + ML + AI + Crypto + Quantum library.
+
+Example:
+    import aimath as am
+    print(am.sqrt(144))
+    print(am.mean([10, 20, 30]))
+"""
+
+# =====================================================
+# CORE
+# =====================================================
+from .core import add, sub, mul, div, square, cube, sqrt, power, percent, percent_change
+
+# =====================================================
+# SCIENTIFIC
+# =====================================================
+from .scientific import (
+    sin,
+    cos,
+    tan,
+    log10,
+    ln,
+    exp,
+    factorial,
+    gcd,
+    lcm,
+    deg2rad,
+    rad2deg,
+)
+
+# =====================================================
+# STATISTICS
+# =====================================================
+from .statistics import mean, median, mode, variance, std, data_range, iqr, z_score
+
+# =====================================================
+# PROBABILITY
+# =====================================================
+from .probability import nCr, nPr, bayes, expected_value
+from .distributions import (
+    normal_pdf,
+    normal_cdf,
+    bernoulli_pmf,
+    binomial_pmf,
+    poisson_pmf,
+    exponential_pdf,
+    uniform_pdf,
+    t_pdf,
+    chi_square_pdf,
+)
+
+# =====================================================
+# MACHINE LEARNING
+# =====================================================
+from .ml import mse, rmse, mae, accuracy, precision, recall, f1_score, r2_score
+
+# =====================================================
+# DEEP LEARNING
+# =====================================================
+from .dl import (
+    sigmoid,
+    relu,
+    tanh,
+    softmax,
+    entropy,
+    kl_divergence,
+    binary_cross_entropy,
+)
+
+# =====================================================
+# NLP
+# =====================================================
+from .nlp import (
+    term_frequency,
+    inverse_document_frequency,
+    tfidf,
+    cosine_similarity,
+    perplexity,
+)
+
+# =====================================================
+# TIME SERIES
+# =====================================================
+from .timeseries import sma, ema
+
+# =====================================================
+# FINANCE
+# =====================================================
+from .finance_math import simple_interest, compound_interest, loan_emi
+
+# =====================================================
+# CRYPTO / BLOCKCHAIN
+# =====================================================
+from .crypto_math import sha256, gas_fee
+
+# =====================================================
+# QUANTUM
+# =====================================================
+from .quantum_math import hadamard, pauli_x
+
+# =====================================================
+# APTITUDE
+# =====================================================
+from .aptitude_math import profit_percent, loss_percent, avg_speed
+
+# =====================================================
+# ALGEBRA
+# =====================================================
+from .algebra import solve_linear, quadratic_roots
+
+# =====================================================
+# GEN-AI (Phase 2)
+# =====================================================
+from .genai import logits_to_prob, softmax_temperature, attention_scores
+
+# =====================================================
+# OPTIMIZATION (Phase 2)
+# =====================================================
+from .optimization import (
+    sgd_update,
+    adam_update,
+    rmsprop_update,
+    lr_step_decay,
+    lr_cosine_anneal,
+    momentum_update,
+)
+
+# =====================================================
+# GRAPH (Phase 2)
+# =====================================================
+from .graph import (
+    bfs_distance,
+    dijkstra_shortest_path,
+)
+
+# =====================================================
+# VISION (Phase 2)
+# =====================================================
+from .vision import conv2d_output_shape, maxpool_output_shape, iou, nms
+
+# =====================================================
+# FULL MATH EXTENSION (Python math module exposed)
+# =====================================================
+from .math_ext import *
+
+# =====================================================
+# BENCHMARK + DOCS
+# =====================================================
+from .benchmark import timeit, mem_profile
+
+
+# =====================================================
+# EXPORTED API LIST
+# =====================================================
+__all__ = [
+    # core
+    "add",
+    "sub",
+    "mul",
+    "div",
+    "square",
+    "cube",
+    "sqrt",
+    "power",
+    "percent",
+    "percent_change",
+    # scientific
+    "sin",
+    "cos",
+    "tan",
+    "log10",
+    "ln",
+    "exp",
+    "factorial",
+    "gcd",
+    "lcm",
+    "deg2rad",
+    "rad2deg",
+    # statistics
+    "mean",
+    "median",
+    "mode",
+    "variance",
+    "std",
+    "data_range",
+    "iqr",
+    "z_score",
+    # probability
+    "nCr",
+    "nPr",
+    "bayes",
+    "expected_value",
+    # distributions
+    "normal_pdf",
+    "normal_cdf",
+    "bernoulli_pmf",
+    "binomial_pmf",
+    "poisson_pmf",
+    "exponential_pdf",
+    "uniform_pdf",
+    "t_pdf",
+    "chi_square_pdf",
+    # ML
+    "mse",
+    "rmse",
+    "mae",
+    "accuracy",
+    "precision",
+    "recall",
+    "f1_score",
+    "r2_score",
+    # DL
+    "sigmoid",
+    "relu",
+    "tanh",
+    "softmax",
+    "entropy",
+    "kl_divergence",
+    "binary_cross_entropy",
+    # NLP
+    "term_frequency",
+    "inverse_document_frequency",
+    "tfidf",
+    "cosine_similarity",
+    "perplexity",
+    # time series
+    "sma",
+    "ema",
+    # finance
+    "simple_interest",
+    "compound_interest",
+    "loan_emi",
+    # crypto
+    "sha256",
+    "gas_fee",
+    # quantum
+    "hadamard",
+    "pauli_x",
+    # aptitude
+    "profit_percent",
+    "loss_percent",
+    "avg_speed",
+    # algebra
+    "solve_linear",
+    "quadratic_roots",
+    # GEN-AI
+    "logits_to_prob",
+    "softmax_temperature",
+    "attention_scores",
+    # optimization
+    "sgd_update",
+    "adam_update",
+    "rmsprop_update",
+    "lr_step_decay",
+    "lr_cosine_anneal",
+    "momentum_update",
+    # graph
+    "bfs_distance",
+    "dijkstra_shortest_path",
+    # vision
+    "conv2d_output_shape",
+    "maxpool_output_shape",
+    "iou",
+    "nms",
+    # math_ext (all math.* names are included automatically)
+    # benchmark
+    "timeit",
+    "mem_profile",
+]

stmath-1.0.0/stmath/algebra.py

@@ -0,0 +1,23 @@
+import cmath
+from typing import Tuple
+
+
+def solve_linear(a: float, b: float) -> float:
+    """Solve ax + b = 0"""
+    if a == 0:
+        raise ZeroDivisionError("a cannot be zero in solve_linear.")
+    return -b / a
+
+
+def quadratic_roots(a: float, b: float, c: float) -> Tuple[complex, complex]:
+    """Solve ax^2 + bx + c = 0 (supports real + complex roots)."""
+    if a == 0:
+        raise ZeroDivisionError("a cannot be zero in quadratic_roots.")
+
+    D = b**2 - 4 * a * c
+    sqrtD = cmath.sqrt(D)
+
+    x1 = (-b + sqrtD) / (2 * a)
+    x2 = (-b - sqrtD) / (2 * a)
+
+    return x1, x2

stmath-1.0.0/stmath/aptitude_math.py

@@ -0,0 +1,20 @@
+from .core import percent
+
+
+def profit_percent(cp, sp):
+    if cp == 0:
+        raise ZeroDivisionError("cp cannot be zero.")
+    return (sp - cp) * 100.0 / cp
+
+
+def loss_percent(cp, sp):
+    if cp == 0:
+        raise ZeroDivisionError("cp cannot be zero.")
+    return (cp - sp) * 100.0 / cp
+
+
+def avg_speed(distance1, speed1, distance2, speed2):
+    """Average speed over two equal distances with different speeds."""
+    time = distance1 / speed1 + distance2 / speed2
+    total_dist = distance1 + distance2
+    return total_dist / time

stmath-1.0.0/stmath/benchmark.py

@@ -0,0 +1,18 @@
+# \"\"\"Simple micro-benchmark helpers\"\"\"
+import time, tracemalloc
+
+
+def timeit(fn, *args, runs=100, **kwargs):
+    t0 = time.perf_counter()
+    for _ in range(runs):
+        fn(*args, **kwargs)
+    t1 = time.perf_counter()
+    return (t1 - t0) / runs
+
+
+def mem_profile(fn, *args, **kwargs):
+    tracemalloc.start()
+    fn(*args, **kwargs)
+    current, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+    return current, peak

stmath-1.0.0/stmath/combinatorics.py

@@ -0,0 +1,54 @@
+# combinatorics.py
+
+import math
+from typing import Iterable
+
+
+def comb(n: int, r: int) -> int:
+    """n choose r"""
+    if r < 0 or r > n:
+        return 0
+    return math.comb(n, r)
+
+
+def perm(n: int, r: int) -> int:
+    """n permute r"""
+    if r < 0 or r > n:
+        return 0
+    return math.perm(n, r)
+
+
+def bayes(p_a: float, p_b: float, p_b_given_a: float) -> float:
+    """P(A|B) = P(B|A)P(A) / P(B)"""
+    if p_b == 0:
+        raise ZeroDivisionError("P(B) cannot be zero")
+    return (p_b_given_a * p_a) / p_b
+
+
+def entropy(p: Iterable[float], base: float = 2.0) -> float:
+    """Shannon entropy of probability list p"""
+    import math
+
+    H = 0.0
+    for pi in p:
+        if pi > 0:
+            H -= pi * math.log(pi, base)
+    return H
+
+
+def kl_divergence(p: Iterable[float], q: Iterable[float], base: float = 2.0) -> float:
+    """KL divergence D(P||Q)"""
+    import math
+
+    p = list(p)
+    q = list(q)
+    if len(p) != len(q):
+        raise ValueError("p and q must have same length")
+    total = 0.0
+    for pi, qi in zip(p, q):
+        if pi == 0:
+            continue
+        if qi == 0:
+            return float("inf")
+        total += pi * math.log(pi / qi, base)
+    return total

stmath-1.0.0/stmath/core.py

@@ -0,0 +1,50 @@
+import math
+from typing import Iterable, List
+
+
+def add(a, b):
+    return a + b
+
+
+def sub(a, b):
+    return a - b
+
+
+def mul(a, b):
+    return a * b
+
+
+def div(a, b):
+    if b == 0:
+        raise ZeroDivisionError("Division by zero is not allowed.")
+    return a / b
+
+
+def square(x):
+    return x * x
+
+
+def cube(x):
+    return x * x * x
+
+
+def sqrt(x):
+    if x < 0:
+        raise ValueError("sqrt() only defined for non-negative numbers.")
+    return math.sqrt(x)
+
+
+def power(x, n):
+    return x**n
+
+
+def percent(part, whole):
+    if whole == 0:
+        raise ZeroDivisionError("whole cannot be zero in percent().")
+    return (part / whole) * 100.0
+
+
+def percent_change(old, new):
+    if old == 0:
+        raise ZeroDivisionError("old value cannot be zero in percent_change().")
+    return ((new - old) / old) * 100.0

stmath-1.0.0/stmath/crypto_math.py

@@ -0,0 +1,17 @@
+import hashlib
+
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def gas_fee(gas_used: int, gwei: float, eth_price: float) -> float:
+    """
+    Rough ETH gas fee in USD.
+    gas_used: e.g. 21000
+    gwei: gas price in gwei
+    eth_price: price of 1 ETH in USD
+    """
+    # 1 gwei = 1e-9 ETH
+    eth_fee = gas_used * gwei * 1e-9
+    return eth_fee * eth_price

stmath-1.0.0/stmath/distributions.py

@@ -0,0 +1,83 @@
+import math
+from .probability import nCr
+
+
+# ---------- Normal ----------
+
+
+def normal_pdf(x: float, mu: float = 0.0, sigma: float = 1.0) -> float:
+    if sigma <= 0:
+        raise ValueError("sigma must be positive.")
+    coef = 1.0 / (sigma * math.sqrt(2.0 * math.pi))
+    expo = -((x - mu) ** 2) / (2.0 * sigma**2)
+    return coef * math.exp(expo)
+
+
+def normal_cdf(x: float, mu: float = 0.0, sigma: float = 1.0) -> float:
+    if sigma <= 0:
+        raise ValueError("sigma must be positive.")
+    z = (x - mu) / (sigma * math.sqrt(2.0))
+    return 0.5 * (1.0 + math.erf(z))
+
+
+# ---------- Discrete ----------
+
+
+def bernoulli_pmf(k: int, p: float) -> float:
+    if not 0 <= p <= 1:
+        raise ValueError("p must be in [0,1].")
+    if k == 1:
+        return p
+    if k == 0:
+        return 1 - p
+    return 0.0
+
+
+def binomial_pmf(k: int, n: int, p: float) -> float:
+    if not 0 <= p <= 1:
+        raise ValueError("p must be in [0,1].")
+    return nCr(n, k) * (p**k) * ((1 - p) ** (n - k))
+
+
+def poisson_pmf(k: int, lam: float) -> float:
+    if k < 0:
+        return 0.0
+    return (lam**k) * math.exp(-lam) / math.factorial(k)
+
+
+# ---------- Continuous ----------
+
+
+def exponential_pdf(x: float, lam: float) -> float:
+    if lam <= 0:
+        raise ValueError("lambda must be positive.")
+    if x < 0:
+        return 0.0
+    return lam * math.exp(-lam * x)
+
+
+def uniform_pdf(x: float, a: float, b: float) -> float:
+    if b <= a:
+        raise ValueError("require b > a in uniform_pdf.")
+    if a <= x <= b:
+        return 1.0 / (b - a)
+    return 0.0
+
+
+def t_pdf(x: float, df: int) -> float:
+    """Student t-distribution pdf."""
+    if df <= 0:
+        raise ValueError("df must be positive.")
+    num = math.gamma((df + 1) / 2)
+    den = math.sqrt(df * math.pi) * math.gamma(df / 2)
+    return num / den * (1 + (x**2) / df) ** (-(df + 1) / 2)
+
+
+def chi_square_pdf(x: float, k: int) -> float:
+    if k <= 0:
+        raise ValueError("k must be positive.")
+    if x < 0:
+        return 0.0
+    num = x ** (k / 2 - 1) * math.exp(-x / 2)
+    den = (2 ** (k / 2)) * math.gamma(k / 2)
+    return num / den