quicktools-atom 0.1.1__tar.gz → 0.3.0__tar.gz

{quicktools_atom-0.1.1 → quicktools_atom-0.3.0}/PKG-INFO

@@ -1,7 +1,11 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.1.1
-Summary: Math and string utilities with a bundled CLI
+Version: 0.3.0
+Summary: Math and string utilities with a bundled CLI, by AtomDev Studios
+Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
+Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
+Project-URL: Repository, https://github.com/Samuel-Peprah-cmd/quicktools
+Project-URL: Documentation, https://samuel-peprah-cmd.github.io/quicktools/
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 

quicktools_atom-0.3.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quicktools-atom"
+version = "0.3.0"
+description = "Math and string utilities with a bundled CLI, by AtomDev Studios"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "Samuel Peprah", email = "windscribe.samuel@gmail.com" }
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/Samuel-Peprah-cmd/quicktools"
+Repository = "https://github.com/Samuel-Peprah-cmd/quicktools"
+Documentation = "https://samuel-peprah-cmd.github.io/quicktools/"
+
+[project.scripts]
+quicktools = "quicktools.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

quicktools_atom-0.3.0/src/quicktools/__init__.py

@@ -0,0 +1,88 @@
+"""
+<p align="center">
+  <img src="assets/AtomDev_Studios.png" alt="AtomDev Studios" width="320" style="border-radius: 8px;">
+</p>
+
+# quicktools
+
+A math and string-manipulation toolkit covering linear algebra, calculus,
+number theory, combinatorics, and text processing — built by **Samuel Peprah**
+under **AtomDev Studios**.
+
+---
+
+## About Samuel Peprah
+
+<p align="center">
+  <img src="assets/sam.png" alt="Samuel Peprah" width="160" style="border-radius: 50%; object-fit: cover;">
+</p>
+
+Samuel Peprah is a software developer, web application developer, and
+Occupational Therapy student at the University of Ghana. Alongside his
+healthcare education, he is also studying Computer Science at the University
+of the People, combining knowledge from both fields to develop practical
+technology solutions.
+
+His interests span full-stack web development, software engineering,
+automation, artificial intelligence, cybersecurity, and health technology.
+He enjoys building scalable applications that solve real-world problems and
+continuously explores new technologies to improve his skills.
+
+Samuel has developed educational platforms, business management systems,
+attendance systems, healthcare applications, and AI-powered solutions. He is
+passionate about creating software that is modern, efficient, secure, and
+user-friendly.
+
+## About AtomDev Studios
+
+AtomDev Studios is the personal software development brand founded by Samuel
+Peprah. The studio specializes in designing and developing modern websites,
+web applications, business management systems, educational platforms, and
+custom software solutions for individuals, startups, schools, and
+organizations.
+
+The mission of AtomDev Studios is to transform ideas into reliable, scalable,
+and innovative digital products that solve real-world problems while
+delivering exceptional user experiences.
+
+### Areas of Expertise
+
+- Full-Stack Web Development
+- Custom Web Applications
+- REST API Development
+- Database Design & Management
+- Educational Technology Platforms
+- Healthcare Technology Solutions
+- AI Integration & Automation
+- UI/UX Design
+- Cloud Deployment & Hosting
+- Website Maintenance & Support
+
+### Technologies
+
+Python • Flask • JavaScript • HTML • CSS • Tailwind CSS • Bootstrap •
+PostgreSQL • SQLite • Git • GitHub • Cloudflare • Docker
+
+### Connect
+
+- LinkedIn: [samuel-peprah-a63598347](https://www.linkedin.com/in/samuel-peprah-a63598347)
+- X (Twitter): [@legend_consult](https://x.com/legend_consult)
+- TikTok: [@legendinlearning](https://www.tiktok.com/@legendinlearning)
+- Instagram: [@ksapeprah](https://www.instagram.com/ksapeprah)
+- GitHub: [Samuel-Peprah-cmd](https://github.com/Samuel-Peprah-cmd)
+
+> "Building innovative software solutions that bridge technology with real-world impact."
+
+---
+
+## Modules
+
+- `mathtools` — primes, GCD/LCM, mean, median, standard deviation
+- `strtools` — palindromes, slugify, edit distance, anagrams, ciphers
+- `linalg` — matrix operations, determinants, inverses, linear systems
+- `calculus` — derivatives, integrals, Taylor series, Newton's method
+- `numbertheory` — extended GCD, modular inverse, sieve, prime factorization
+- `combinatorics` — permutations, combinations, Catalan numbers, Fibonacci
+"""
+
+__version__ = "0.2.0"

quicktools_atom-0.3.0/src/quicktools/calculus.py

@@ -0,0 +1,115 @@
+"""Calculus: numerical differentiation, integration, and series approximations."""
+import math
+from typing import Callable
+
+
+def derivative(f: Callable[[float], float], x: float, h: float = 1e-6) -> float:
+    """Approximate f'(x) using the central difference method."""
+    return (f(x + h) - f(x - h)) / (2 * h)
+
+
+def second_derivative(f: Callable[[float], float], x: float, h: float = 1e-4) -> float:
+    """Approximate f''(x) using the central difference method."""
+    return (f(x + h) - 2 * f(x) + f(x - h)) / (h ** 2)
+
+
+def integral_trapezoidal(f: Callable[[float], float], a: float, b: float, n: int = 1000) -> float:
+    """Approximate the definite integral of f from a to b using the trapezoidal rule."""
+    if n <= 0:
+        raise ValueError("n must be positive")
+    h = (b - a) / n
+    total = (f(a) + f(b)) / 2
+    for i in range(1, n):
+        total += f(a + i * h)
+    return total * h
+
+
+def integral_simpson(f: Callable[[float], float], a: float, b: float, n: int = 1000) -> float:
+    """Approximate the definite integral of f from a to b using Simpson's rule (n must be even)."""
+    if n % 2 != 0:
+        n += 1
+    h = (b - a) / n
+    total = f(a) + f(b)
+    for i in range(1, n):
+        coeff = 4 if i % 2 != 0 else 2
+        total += coeff * f(a + i * h)
+    return total * h / 3
+
+
+def taylor_series_exp(x: float, terms: int = 15) -> float:
+    """Approximate e^x using its Taylor series expansion around 0."""
+    return sum((x ** n) / math.factorial(n) for n in range(terms))
+
+
+def taylor_series_sin(x: float, terms: int = 15) -> float:
+    """Approximate sin(x) using its Taylor series expansion around 0."""
+    return sum(((-1) ** n) * (x ** (2 * n + 1)) / math.factorial(2 * n + 1) for n in range(terms))
+
+
+def taylor_series_cos(x: float, terms: int = 15) -> float:
+    """Approximate cos(x) using its Taylor series expansion around 0."""
+    return sum(((-1) ** n) * (x ** (2 * n)) / math.factorial(2 * n) for n in range(terms))
+
+
+def newtons_method(f: Callable[[float], float], x0: float, tol: float = 1e-10, max_iter: int = 100) -> float:
+    """Find a root of f near x0 using Newton's method."""
+    x = x0
+    for _ in range(max_iter):
+        fx = f(x)
+        if abs(fx) < tol:
+            return x
+        dfx = derivative(f, x)
+        if dfx == 0:
+            raise ZeroDivisionError("Derivative is zero; Newton's method failed")
+        x = x - fx / dfx
+    return x
+
+def bisection_method(f, a: float, b: float, tol: float = 1e-10, max_iter: int = 200) -> float:
+    """Find a root of f within [a, b] using the bisection method. Requires f(a) and f(b) to have opposite signs."""
+    if f(a) * f(b) > 0:
+        raise ValueError("f(a) and f(b) must have opposite signs")
+    for _ in range(max_iter):
+        mid = (a + b) / 2
+        if abs(f(mid)) < tol or (b - a) / 2 < tol:
+            return mid
+        if f(a) * f(mid) < 0:
+            b = mid
+        else:
+            a = mid
+    return (a + b) / 2
+
+
+def secant_method(f, x0: float, x1: float, tol: float = 1e-10, max_iter: int = 200) -> float:
+    """Find a root of f near x0 and x1 using the secant method (no derivative required)."""
+    for _ in range(max_iter):
+        fx0, fx1 = f(x0), f(x1)
+        if fx1 - fx0 == 0:
+            raise ZeroDivisionError("Secant method failed: division by zero")
+        x2 = x1 - fx1 * (x1 - x0) / (fx1 - fx0)
+        if abs(x2 - x1) < tol:
+            return x2
+        x0, x1 = x1, x2
+    return x1
+
+
+def partial_derivative(f, point: list[float], index: int, h: float = 1e-6) -> float:
+    """Approximate the partial derivative of a multivariable function f at `point`,
+    with respect to the variable at position `index`."""
+    point_plus = list(point)
+    point_minus = list(point)
+    point_plus[index] += h
+    point_minus[index] -= h
+    return (f(*point_plus) - f(*point_minus)) / (2 * h)
+
+
+def arc_length(f, a: float, b: float, n: int = 1000) -> float:
+    """Approximate the arc length of y = f(x) from x=a to x=b."""
+    def integrand(x: float) -> float:
+        return math.sqrt(1 + derivative(f, x) ** 2)
+    return integral_simpson(integrand, a, b, n)
+
+
+def limit_approximation(f, x: float, h: float = 1e-6) -> float:
+    """Approximate the limit of f(t) as t approaches x, by averaging values just before and after x
+    (useful for functions undefined exactly at x, e.g. removable discontinuities)."""
+    return (f(x - h) + f(x + h)) / 2

quicktools_atom-0.3.0/src/quicktools/combinatorics.py

@@ -0,0 +1,88 @@
+"""Combinatorics: permutations, combinations, and counting sequences."""
+import math
+
+
+def permutations_count(n: int, r: int) -> int:
+    """Number of ways to arrange r items out of n, order matters: nPr."""
+    if r > n or r < 0:
+        return 0
+    return math.factorial(n) // math.factorial(n - r)
+
+
+def combinations_count(n: int, r: int) -> int:
+    """Number of ways to choose r items out of n, order doesn't matter: nCr."""
+    if r > n or r < 0:
+        return 0
+    return math.factorial(n) // (math.factorial(r) * math.factorial(n - r))
+
+
+def catalan_number(n: int) -> int:
+    """The nth Catalan number — counts things like valid bracket sequences and binary tree shapes."""
+    return combinations_count(2 * n, n) // (n + 1)
+
+
+def fibonacci(n: int) -> int:
+    """The nth Fibonacci number (0-indexed: fibonacci(0) == 0)."""
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a
+
+
+def binomial_expansion_coeffs(n: int) -> list[int]:
+    """Coefficients of (x + y)^n, i.e. row n of Pascal's triangle."""
+    return [combinations_count(n, k) for k in range(n + 1)]
+
+def multinomial_coefficient(n: int, ks: list[int]) -> int:
+    """Number of ways to divide n items into groups of sizes ks (which must sum to n)."""
+    if sum(ks) != n:
+        raise ValueError("The group sizes must sum to n")
+    result = math.factorial(n)
+    for k in ks:
+        result //= math.factorial(k)
+    return result
+
+
+def stirling_second_kind(n: int, k: int) -> int:
+    """Number of ways to partition a set of n objects into k non-empty subsets."""
+    if k == 0:
+        return 1 if n == 0 else 0
+    if k > n or n < 0:
+        return 0
+    if k == n:
+        return 1
+    total = 0
+    for j in range(k + 1):
+        sign = (-1) ** (k - j)
+        total += sign * combinations_count(k, j) * (j ** n)
+    return total // math.factorial(k)
+
+
+def derangements_count(n: int) -> int:
+    """Number of permutations of n items where no item ends up in its original position."""
+    if n == 0:
+        return 1
+    if n == 1:
+        return 0
+    a, b = 1, 0
+    for i in range(2, n + 1):
+        a, b = b, (i - 1) * (a + b)
+    return b
+
+
+def integer_partitions_count(n: int) -> int:
+    """Number of ways to write n as a sum of positive integers, order not mattering."""
+    if n < 0:
+        return 0
+    partitions = [1] + [0] * n
+    for k in range(1, n + 1):
+        for i in range(k, n + 1):
+            partitions[i] += partitions[i - k]
+    return partitions[n]
+
+
+def combinations_with_replacement_count(n: int, r: int) -> int:
+    """Number of ways to choose r items from n types, with repetition allowed and order not mattering."""
+    return combinations_count(n + r - 1, r)

quicktools_atom-0.3.0/src/quicktools/linalg.py

@@ -0,0 +1,188 @@
+"""Linear algebra: matrix operations, determinants, inverses, linear systems.
+
+Matrices are represented as lists of lists, e.g. [[1, 2], [3, 4]].
+No external dependencies (no numpy) — pure Python.
+"""
+import math
+
+
+def matrix_add(a: list[list[float]], b: list[list[float]]) -> list[list[float]]:
+    """Add two matrices of the same shape."""
+    return [[a[i][j] + b[i][j] for j in range(len(a[0]))] for i in range(len(a))]
+
+
+def matrix_multiply(a: list[list[float]], b: list[list[float]]) -> list[list[float]]:
+    """Multiply two matrices (a is m x n, b is n x p, result is m x p)."""
+    rows_a, cols_a = len(a), len(a[0])
+    rows_b, cols_b = len(b), len(b[0])
+    if cols_a != rows_b:
+        raise ValueError(f"Cannot multiply {rows_a}x{cols_a} by {rows_b}x{cols_b}")
+    result = [[0.0] * cols_b for _ in range(rows_a)]
+    for i in range(rows_a):
+        for j in range(cols_b):
+            result[i][j] = sum(a[i][k] * b[k][j] for k in range(cols_a))
+    return result
+
+
+def transpose(a: list[list[float]]) -> list[list[float]]:
+    """Return the transpose of a matrix."""
+    return [list(row) for row in zip(*a)]
+
+
+def identity(n: int) -> list[list[float]]:
+    """Return the n x n identity matrix."""
+    return [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
+
+
+def determinant(a: list[list[float]]) -> float:
+    """Determinant of a square matrix via cofactor expansion (Laplace expansion)."""
+    n = len(a)
+    if n != len(a[0]):
+        raise ValueError("Matrix must be square")
+    if n == 1:
+        return a[0][0]
+    if n == 2:
+        return a[0][0] * a[1][1] - a[0][1] * a[1][0]
+    det = 0.0
+    for col in range(n):
+        minor = [row[:col] + row[col + 1:] for row in a[1:]]
+        sign = 1 if col % 2 == 0 else -1
+        det += sign * a[0][col] * determinant(minor)
+    return det
+
+
+def inverse(a: list[list[float]]) -> list[list[float]]:
+    """Inverse of a square matrix using Gauss-Jordan elimination."""
+    n = len(a)
+    aug = [row[:] + [1.0 if i == j else 0.0 for j in range(n)] for i, row in enumerate(a)]
+
+    for col in range(n):
+        pivot_row = max(range(col, n), key=lambda r: abs(aug[r][col]))
+        if abs(aug[pivot_row][col]) < 1e-12:
+            raise ValueError("Matrix is singular and cannot be inverted")
+        aug[col], aug[pivot_row] = aug[pivot_row], aug[col]
+
+        pivot_val = aug[col][col]
+        aug[col] = [x / pivot_val for x in aug[col]]
+
+        for r in range(n):
+            if r != col:
+                factor = aug[r][col]
+                aug[r] = [aug[r][k] - factor * aug[col][k] for k in range(2 * n)]
+
+    return [row[n:] for row in aug]
+
+
+def solve_linear_system(a: list[list[float]], b: list[float]) -> list[float]:
+    """Solve Ax = b for x, given square matrix A and vector b."""
+    n = len(a)
+    aug = [a[i][:] + [b[i]] for i in range(n)]
+
+    for col in range(n):
+        pivot_row = max(range(col, n), key=lambda r: abs(aug[r][col]))
+        if abs(aug[pivot_row][col]) < 1e-12:
+            raise ValueError("System has no unique solution (singular matrix)")
+        aug[col], aug[pivot_row] = aug[pivot_row], aug[col]
+
+        pivot_val = aug[col][col]
+        aug[col] = [x / pivot_val for x in aug[col]]
+
+        for r in range(n):
+            if r != col:
+                factor = aug[r][col]
+                aug[r] = [aug[r][k] - factor * aug[col][k] for k in range(n + 1)]
+
+    return [row[n] for row in aug]
+
+
+def trace(a: list[list[float]]) -> float:
+    """Sum of the diagonal elements of a square matrix."""
+    return sum(a[i][i] for i in range(len(a)))
+
+def dot_product(v1: list[float], v2: list[float]) -> float:
+    """Dot product of two equal-length vectors."""
+    if len(v1) != len(v2):
+        raise ValueError("Vectors must be the same length")
+    return sum(a * b for a, b in zip(v1, v2))
+
+
+def cross_product(v1: list[float], v2: list[float]) -> list[float]:
+    """Cross product of two 3D vectors."""
+    if len(v1) != 3 or len(v2) != 3:
+        raise ValueError("Cross product requires two 3D vectors")
+    return [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0],
+    ]
+
+
+def vector_magnitude(v: list[float]) -> float:
+    """Euclidean length (magnitude) of a vector."""
+    return math.sqrt(sum(x ** 2 for x in v))
+
+
+def normalize_vector(v: list[float]) -> list[float]:
+    """Scale a vector to unit length (magnitude 1)."""
+    mag = vector_magnitude(v)
+    if mag == 0:
+        raise ValueError("Cannot normalize the zero vector")
+    return [x / mag for x in v]
+
+
+def vector_add(v1: list[float], v2: list[float]) -> list[float]:
+    """Add two equal-length vectors."""
+    if len(v1) != len(v2):
+        raise ValueError("Vectors must be the same length")
+    return [a + b for a, b in zip(v1, v2)]
+
+
+def vector_subtract(v1: list[float], v2: list[float]) -> list[float]:
+    """Subtract v2 from v1 (equal-length vectors)."""
+    if len(v1) != len(v2):
+        raise ValueError("Vectors must be the same length")
+    return [a - b for a, b in zip(v1, v2)]
+
+
+def scalar_multiply(a: list[list[float]], scalar: float) -> list[list[float]]:
+    """Multiply every element of a matrix by a scalar."""
+    return [[x * scalar for x in row] for row in a]
+
+
+def matrix_power(a: list[list[float]], n: int) -> list[list[float]]:
+    """Raise a square matrix to the n-th power (n >= 0) via repeated multiplication."""
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    size = len(a)
+    result = identity(size)
+    for _ in range(n):
+        result = matrix_multiply(result, a)
+    return result
+
+
+def is_symmetric(a: list[list[float]]) -> bool:
+    """Return True if a square matrix equals its own transpose."""
+    return a == transpose(a)
+
+
+def rank(a: list[list[float]]) -> int:
+    """Rank of a matrix, computed via Gaussian elimination to row echelon form."""
+    mat = [row[:] for row in a]
+    rows, cols = len(mat), len(mat[0])
+    rank_count = 0
+    for col in range(cols):
+        pivot_row = None
+        for r in range(rank_count, rows):
+            if abs(mat[r][col]) > 1e-12:
+                pivot_row = r
+                break
+        if pivot_row is None:
+            continue
+        mat[rank_count], mat[pivot_row] = mat[pivot_row], mat[rank_count]
+        for r in range(rank_count + 1, rows):
+            factor = mat[r][col] / mat[rank_count][col]
+            mat[r] = [mat[r][k] - factor * mat[rank_count][k] for k in range(cols)]
+        rank_count += 1
+        if rank_count == rows:
+            break
+    return rank_count

quicktools_atom-0.3.0/src/quicktools/mathtools.py

@@ -0,0 +1,128 @@
+"""Math utilities: primes, number theory, and basic statistics."""
+import math
+
+
+def is_prime(n: int) -> bool:
+    """Return True if n is a prime number."""
+    if n < 2:
+        return False
+    for i in range(2, int(math.sqrt(n)) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+
+def gcd(a: int, b: int) -> int:
+    """Greatest common divisor of a and b."""
+    return math.gcd(a, b)
+
+
+def lcm(a: int, b: int) -> int:
+    """Least common multiple of a and b."""
+    return abs(a * b) // math.gcd(a, b)
+
+
+def mean(numbers: list[float]) -> float:
+    """Arithmetic mean of a list of numbers."""
+    if not numbers:
+        raise ValueError("mean() requires at least one number")
+    return sum(numbers) / len(numbers)
+
+
+def median(numbers: list[float]) -> float:
+    """Median of a list of numbers."""
+    if not numbers:
+        raise ValueError("median() requires at least one number")
+    nums = sorted(numbers)
+    n = len(nums)
+    mid = n // 2
+    if n % 2 == 0:
+        return (nums[mid - 1] + nums[mid]) / 2
+    return nums[mid]
+
+
+def std_dev(numbers: list[float]) -> float:
+    """Population standard deviation of a list of numbers."""
+    if not numbers:
+        raise ValueError("std_dev() requires at least one number")
+    m = mean(numbers)
+    variance = sum((x - m) ** 2 for x in numbers) / len(numbers)
+    return math.sqrt(variance)
+
+
+def variance(numbers: list[float]) -> float:
+    """Population variance of a list of numbers."""
+    if not numbers:
+        raise ValueError("variance() requires at least one number")
+    m = mean(numbers)
+    return sum((x - m) ** 2 for x in numbers) / len(numbers)
+
+
+def is_perfect_square(n: int) -> bool:
+    """Return True if n is a perfect square."""
+    if n < 0:
+        return False
+    root = int(math.isqrt(n))
+    return root * root == n
+
+
+def harmonic_mean(numbers: list[float]) -> float:
+    """Harmonic mean of a list of positive numbers."""
+    if not numbers:
+        raise ValueError("harmonic_mean() requires at least one number")
+    return len(numbers) / sum(1 / x for x in numbers)
+
+
+def geometric_mean(numbers: list[float]) -> float:
+    """Geometric mean of a list of positive numbers."""
+    if not numbers:
+        raise ValueError("geometric_mean() requires at least one number")
+    product = 1.0
+    for x in numbers:
+        product *= x
+    return product ** (1 / len(numbers))
+
+
+def mode(numbers: list[float]) -> list[float]:
+    """Return the most frequently occurring value(s) in a list of numbers."""
+    if not numbers:
+        raise ValueError("mode() requires at least one number")
+    counts: dict[float, int] = {}
+    for x in numbers:
+        counts[x] = counts.get(x, 0) + 1
+    max_count = max(counts.values())
+    return [val for val, cnt in counts.items() if cnt == max_count]
+
+
+def percentile(numbers: list[float], p: float) -> float:
+    """The p-th percentile (0-100) of a list of numbers, using linear interpolation."""
+    if not numbers:
+        raise ValueError("percentile() requires at least one number")
+    if not (0 <= p <= 100):
+        raise ValueError("p must be between 0 and 100")
+    data = sorted(numbers)
+    index = (p / 100) * (len(data) - 1)
+    lower = int(index)
+    upper = min(lower + 1, len(data) - 1)
+    frac = index - lower
+    return data[lower] + frac * (data[upper] - data[lower])
+
+
+def covariance(x: list[float], y: list[float]) -> float:
+    """Population covariance between two equal-length lists of numbers."""
+    if len(x) != len(y) or not x:
+        raise ValueError("covariance() requires two non-empty lists of equal length")
+    mx, my = mean(x), mean(y)
+    return sum((xi - mx) * (yi - my) for xi, yi in zip(x, y)) / len(x)
+
+
+def correlation(x: list[float], y: list[float]) -> float:
+    """Pearson correlation coefficient between two equal-length lists of numbers."""
+    return covariance(x, y) / (std_dev(x) * std_dev(y))
+
+
+def data_range(numbers: list[float]) -> float:
+    """Difference between the maximum and minimum values in a list."""
+    if not numbers:
+        raise ValueError("data_range() requires at least one number")
+    return max(numbers) - min(numbers)

quicktools_atom-0.3.0/src/quicktools/numbertheory.py

@@ -0,0 +1,149 @@
+"""Number theory: primes, modular arithmetic, and related functions."""
+
+
+def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
+    """Return (g, x, y) such that a*x + b*y = g = gcd(a, b)."""
+    if a == 0:
+        return b, 0, 1
+    g, x1, y1 = extended_gcd(b % a, a)
+    return g, y1 - (b // a) * x1, x1
+
+
+def mod_inverse(a: int, m: int) -> int:
+    """Return the modular multiplicative inverse of a modulo m."""
+    g, x, _ = extended_gcd(a % m, m)
+    if g != 1:
+        raise ValueError(f"No modular inverse exists for {a} mod {m}")
+    return x % m
+
+
+def sieve_of_eratosthenes(limit: int) -> list[int]:
+    """Return all prime numbers up to and including `limit`."""
+    if limit < 2:
+        return []
+    is_prime_arr = [True] * (limit + 1)
+    is_prime_arr[0] = is_prime_arr[1] = False
+    for i in range(2, int(limit ** 0.5) + 1):
+        if is_prime_arr[i]:
+            for multiple in range(i * i, limit + 1, i):
+                is_prime_arr[multiple] = False
+    return [i for i, prime in enumerate(is_prime_arr) if prime]
+
+
+def prime_factors(n: int) -> dict[int, int]:
+    """Return the prime factorization of n as {prime: exponent}."""
+    if n < 2:
+        return {}
+    factors = {}
+    d = 2
+    while d * d <= n:
+        while n % d == 0:
+            factors[d] = factors.get(d, 0) + 1
+            n //= d
+        d += 1
+    if n > 1:
+        factors[n] = factors.get(n, 0) + 1
+    return factors
+
+
+def euler_totient(n: int) -> int:
+    """Count integers up to n that are coprime with n (Euler's totient function)."""
+    result = n
+    factors = prime_factors(n)
+    for p in factors:
+        result -= result // p
+    return result
+
+
+def is_coprime(a: int, b: int) -> bool:
+    """Return True if a and b share no common factors other than 1."""
+    import math
+    return math.gcd(a, b) == 1
+
+def chinese_remainder_theorem(remainders: list[int], moduli: list[int]) -> int:
+    """Solve a system of congruences x = remainders[i] (mod moduli[i]) for all i,
+    returning the smallest non-negative solution (moduli must be pairwise coprime)."""
+    total_modulus = 1
+    for m in moduli:
+        total_modulus *= m
+    result = 0
+    for r, m in zip(remainders, moduli):
+        partial = total_modulus // m
+        result += r * partial * mod_inverse(partial, m)
+    return result % total_modulus
+
+
+def sum_of_divisors(n: int) -> int:
+    """Sum of all positive divisors of n, including 1 and n itself."""
+    if n < 1:
+        raise ValueError("n must be a positive integer")
+    total = 0
+    for i in range(1, int(n ** 0.5) + 1):
+        if n % i == 0:
+            total += i
+            if i != n // i:
+                total += n // i
+    return total
+
+
+def is_perfect_number(n: int) -> bool:
+    """Return True if n equals the sum of its proper divisors (e.g. 6, 28, 496)."""
+    if n < 1:
+        return False
+    return sum_of_divisors(n) - n == n
+
+
+def is_amicable_pair(a: int, b: int) -> bool:
+    """Return True if a and b form an amicable pair (each equals the sum of the other's proper divisors)."""
+    return (sum_of_divisors(a) - a == b) and (sum_of_divisors(b) - b == a) and a != b
+
+
+def digital_root(n: int) -> int:
+    """Repeatedly sum the digits of n until a single digit remains."""
+    n = abs(n)
+    while n >= 10:
+        n = sum(int(d) for d in str(n))
+    return n
+
+
+def collatz_sequence(n: int) -> list[int]:
+    """Return the Collatz sequence starting at n, ending at 1."""
+    if n < 1:
+        raise ValueError("n must be a positive integer")
+    sequence = [n]
+    while n != 1:
+        n = n // 2 if n % 2 == 0 else 3 * n + 1
+        sequence.append(n)
+    return sequence
+
+
+def next_prime(n: int) -> int:
+    """Return the smallest prime strictly greater than n."""
+    candidate = n + 1
+    while True:
+        is_p = True
+        for i in range(2, int(candidate ** 0.5) + 1):
+            if candidate % i == 0:
+                is_p = False
+                break
+        if is_p and candidate > 1:
+            return candidate
+        candidate += 1
+
+
+def nth_prime(n: int) -> int:
+    """Return the nth prime number (1-indexed: nth_prime(1) == 2)."""
+    if n < 1:
+        raise ValueError("n must be a positive integer")
+    count = 0
+    candidate = 1
+    while count < n:
+        candidate = next_prime(candidate)
+        count += 1
+    return candidate
+
+
+def is_palindromic_number(n: int) -> bool:
+    """Return True if n reads the same forwards and backwards."""
+    s = str(n)
+    return s == s[::-1]

quicktools_atom-0.3.0/src/quicktools/strtools.py

@@ -0,0 +1,236 @@
+"""String utilities: text checks, transforms, and simple ciphers."""
+import re
+
+
+def is_palindrome(text: str) -> bool:
+    """Return True if text reads the same forwards and backwards (ignoring case/spaces)."""
+    cleaned = re.sub(r"[^a-zA-Z0-9]", "", text).lower()
+    return cleaned == cleaned[::-1]
+
+
+def slugify(text: str) -> str:
+    """Convert text into a url-friendly slug, e.g. 'Hello World!' -> 'hello-world'."""
+    text = text.lower().strip()
+    text = re.sub(r"[^a-z0-9]+", "-", text)
+    return text.strip("-")
+
+
+def word_frequency(text: str) -> dict[str, int]:
+    """Count occurrences of each word in text (case-insensitive)."""
+    words = re.findall(r"[a-zA-Z']+", text.lower())
+    freq: dict[str, int] = {}
+    for w in words:
+        freq[w] = freq.get(w, 0) + 1
+    return freq
+
+
+def caesar_cipher(text: str, shift: int) -> str:
+    """Shift each letter in text by `shift` positions (Caesar cipher). Negative shift decodes."""
+    result = []
+    for ch in text:
+        if ch.isalpha():
+            base = ord('A') if ch.isupper() else ord('a')
+            result.append(chr((ord(ch) - base + shift) % 26 + base))
+        else:
+            result.append(ch)
+    return "".join(result)
+
+
+def reverse_words(text: str) -> str:
+    """Reverse the order of words in a sentence."""
+    return " ".join(text.split()[::-1])
+
+
+def levenshtein_distance(s1: str, s2: str) -> int:
+    """Minimum number of single-character edits (insertions, deletions, substitutions)
+    needed to turn s1 into s2."""
+    if len(s1) < len(s2):
+        return levenshtein_distance(s2, s1)
+    if len(s2) == 0:
+        return len(s1)
+
+    previous_row = list(range(len(s2) + 1))
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+    return previous_row[-1]
+
+
+def is_anagram(s1: str, s2: str) -> bool:
+    """Return True if s1 and s2 use exactly the same letters (ignoring case/spaces)."""
+    clean1 = re.sub(r"[^a-z0-9]", "", s1.lower())
+    clean2 = re.sub(r"[^a-z0-9]", "", s2.lower())
+    return sorted(clean1) == sorted(clean2)
+
+
+def to_snake_case(text: str) -> str:
+    """Convert 'camelCase' or 'Title Case' text into 'snake_case'."""
+    text = re.sub(r"(?<!^)(?=[A-Z])", "_", text)
+    text = re.sub(r"[\s\-]+", "_", text)
+    return text.lower().strip("_")
+
+
+def to_camel_case(text: str) -> str:
+    """Convert 'snake_case' or 'kebab-case' text into 'camelCase'."""
+    parts = re.split(r"[_\-\s]+", text.strip())
+    if not parts:
+        return ""
+    return parts[0].lower() + "".join(p.capitalize() for p in parts[1:])
+
+
+def rot13(text: str) -> str:
+    """Apply the ROT13 cipher (Caesar cipher with a fixed shift of 13)."""
+    return caesar_cipher(text, 13)
+
+
+def vigenere_cipher(text: str, key: str, decode: bool = False) -> str:
+    """Encode or decode text using the Vigenere cipher with the given key."""
+    result = []
+    key = key.lower()
+    key_index = 0
+    for ch in text:
+        if ch.isalpha():
+            shift = ord(key[key_index % len(key)]) - ord('a')
+            if decode:
+                shift = -shift
+            base = ord('A') if ch.isupper() else ord('a')
+            result.append(chr((ord(ch) - base + shift) % 26 + base))
+            key_index += 1
+        else:
+            result.append(ch)
+    return "".join(result)
+
+def longest_common_subsequence(s1: str, s2: str) -> str:
+    """The longest sequence of characters that appears in both strings, in order (not necessarily contiguous)."""
+    m, n = len(s1), len(s2)
+    dp = [[""] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if s1[i - 1] == s2[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + s1[i - 1]
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], key=len)
+    return dp[m][n]
+
+
+def run_length_encode(text: str) -> str:
+    """Compress text using run-length encoding, e.g. 'aaabbc' -> '3a2b1c'."""
+    if not text:
+        return ""
+    result = []
+    count = 1
+    prev = text[0]
+    for ch in text[1:]:
+        if ch == prev:
+            count += 1
+        else:
+            result.append(f"{count}{prev}")
+            prev = ch
+            count = 1
+    result.append(f"{count}{prev}")
+    return "".join(result)
+
+
+def run_length_decode(encoded: str) -> str:
+    """Decompress a run-length encoded string produced by run_length_encode()."""
+    result = []
+    count_str = ""
+    for ch in encoded:
+        if ch.isdigit():
+            count_str += ch
+        else:
+            result.append(ch * int(count_str))
+            count_str = ""
+    return "".join(result)
+
+
+def jaccard_similarity(s1: str, s2: str) -> float:
+    """Word-level similarity between two texts: size of the word intersection over the union (0 to 1)."""
+    words1 = set(re.findall(r"[a-zA-Z']+", s1.lower()))
+    words2 = set(re.findall(r"[a-zA-Z']+", s2.lower()))
+    if not words1 and not words2:
+        return 1.0
+    return len(words1 & words2) / len(words1 | words2)
+
+
+def word_count(text: str) -> int:
+    """Count the number of words in text."""
+    return len(re.findall(r"[a-zA-Z']+", text))
+
+
+def char_frequency(text: str) -> dict[str, int]:
+    """Count occurrences of each character in text (case-sensitive, includes all characters)."""
+    freq: dict[str, int] = {}
+    for ch in text:
+        freq[ch] = freq.get(ch, 0) + 1
+    return freq
+
+
+def most_common_word(text: str) -> str:
+    """Return the most frequently occurring word in text (case-insensitive)."""
+    freq = word_frequency(text)
+    if not freq:
+        raise ValueError("Text contains no words")
+    return max(freq, key=freq.get)
+
+
+def title_case(text: str) -> str:
+    """Capitalize the first letter of every word in text."""
+    return " ".join(w.capitalize() for w in text.split())
+
+
+def remove_vowels(text: str) -> str:
+    """Remove all vowels (a, e, i, o, u) from text, case-insensitive."""
+    return re.sub(r"[aeiouAEIOU]", "", text)
+
+
+def count_vowels_consonants(text: str) -> tuple[int, int]:
+    """Count the number of vowels and consonants in text (letters only)."""
+    vowels = sum(1 for ch in text.lower() if ch in "aeiou")
+    consonants = sum(1 for ch in text.lower() if ch.isalpha() and ch not in "aeiou")
+    return vowels, consonants
+
+
+def hash_text(text: str, algorithm: str = "sha256") -> str:
+    """Return the hex digest of text using the given hash algorithm (e.g. 'md5', 'sha1', 'sha256')."""
+    import hashlib
+    h = hashlib.new(algorithm)
+    h.update(text.encode("utf-8"))
+    return h.hexdigest()
+
+
+def is_pangram(text: str) -> bool:
+    """Return True if text contains every letter of the alphabet at least once."""
+    letters = set(ch for ch in text.lower() if ch.isalpha())
+    return len(letters) == 26
+
+
+def wrap_text(text: str, width: int = 70) -> str:
+    """Wrap text so no line exceeds `width` characters."""
+    import textwrap
+    return textwrap.fill(text, width=width)
+
+
+def longest_word(text: str) -> str:
+    """Return the longest word in text (first one found in case of a tie)."""
+    words = re.findall(r"[a-zA-Z']+", text)
+    if not words:
+        raise ValueError("Text contains no words")
+    return max(words, key=len)
+
+
+def base64_encode(text: str) -> str:
+    """Encode text into base64."""
+    import base64
+    return base64.b64encode(text.encode("utf-8")).decode("ascii")
+
+
+def base64_decode(encoded: str) -> str:
+    """Decode a base64-encoded string back into text."""
+    import base64
+    return base64.b64decode(encoded.encode("ascii")).decode("utf-8")

{quicktools_atom-0.1.1 → quicktools_atom-0.3.0}/src/quicktools_atom.egg-info/PKG-INFO

@@ -1,7 +1,11 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.1.1
-Summary: Math and string utilities with a bundled CLI
+Version: 0.3.0
+Summary: Math and string utilities with a bundled CLI, by AtomDev Studios
+Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
+Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
+Project-URL: Repository, https://github.com/Samuel-Peprah-cmd/quicktools
+Project-URL: Documentation, https://samuel-peprah-cmd.github.io/quicktools/
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 

{quicktools_atom-0.1.1 → quicktools_atom-0.3.0}/src/quicktools_atom.egg-info/SOURCES.txt

@@ -1,8 +1,12 @@
 README.md
 pyproject.toml
 src/quicktools/__init__.py
+src/quicktools/calculus.py
 src/quicktools/cli.py
+src/quicktools/combinatorics.py
+src/quicktools/linalg.py
 src/quicktools/mathtools.py
+src/quicktools/numbertheory.py
 src/quicktools/strtools.py
 src/quicktools_atom.egg-info/PKG-INFO
 src/quicktools_atom.egg-info/SOURCES.txt

quicktools_atom-0.1.1/pyproject.toml

@@ -1,17 +0,0 @@
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "quicktools-atom"
-version = "0.1.1"
-description = "Math and string utilities with a bundled CLI"
-requires-python = ">=3.9"
-readme = "README.md"
-dependencies = []
-
-[project.scripts]
-quicktools = "quicktools.cli:main"
-
-[tool.setuptools.packages.find]
-where = ["src"]

quicktools_atom-0.1.1/src/quicktools/__init__.py

@@ -1,3 +0,0 @@
-"""quicktools: a small toolkit with math and string utilities."""
-
-__version__ = "0.1.0"

quicktools_atom-0.1.1/src/quicktools/mathtools.py

@@ -1,50 +0,0 @@
-"""Math utilities: primes, number theory, and basic statistics."""
-import math
-
-
-def is_prime(n: int) -> bool:
-    """Return True if n is a prime number."""
-    if n < 2:
-        return False
-    for i in range(2, int(math.sqrt(n)) + 1):
-        if n % i == 0:
-            return False
-    return True
-
-
-def gcd(a: int, b: int) -> int:
-    """Greatest common divisor of a and b."""
-    return math.gcd(a, b)
-
-
-def lcm(a: int, b: int) -> int:
-    """Least common multiple of a and b."""
-    return abs(a * b) // math.gcd(a, b)
-
-
-def mean(numbers: list[float]) -> float:
-    """Arithmetic mean of a list of numbers."""
-    if not numbers:
-        raise ValueError("mean() requires at least one number")
-    return sum(numbers) / len(numbers)
-
-
-def median(numbers: list[float]) -> float:
-    """Median of a list of numbers."""
-    if not numbers:
-        raise ValueError("median() requires at least one number")
-    nums = sorted(numbers)
-    n = len(nums)
-    mid = n // 2
-    if n % 2 == 0:
-        return (nums[mid - 1] + nums[mid]) / 2
-    return nums[mid]
-
-
-def std_dev(numbers: list[float]) -> float:
-    """Population standard deviation of a list of numbers."""
-    if not numbers:
-        raise ValueError("std_dev() requires at least one number")
-    m = mean(numbers)
-    variance = sum((x - m) ** 2 for x in numbers) / len(numbers)
-    return math.sqrt(variance)

quicktools_atom-0.1.1/src/quicktools/strtools.py

@@ -1,41 +0,0 @@
-"""String utilities: text checks, transforms, and simple ciphers."""
-import re
-
-
-def is_palindrome(text: str) -> bool:
-    """Return True if text reads the same forwards and backwards (ignoring case/spaces)."""
-    cleaned = re.sub(r"[^a-zA-Z0-9]", "", text).lower()
-    return cleaned == cleaned[::-1]
-
-
-def slugify(text: str) -> str:
-    """Convert text into a url-friendly slug, e.g. 'Hello World!' -> 'hello-world'."""
-    text = text.lower().strip()
-    text = re.sub(r"[^a-z0-9]+", "-", text)
-    return text.strip("-")
-
-
-def word_frequency(text: str) -> dict[str, int]:
-    """Count occurrences of each word in text (case-insensitive)."""
-    words = re.findall(r"[a-zA-Z']+", text.lower())
-    freq: dict[str, int] = {}
-    for w in words:
-        freq[w] = freq.get(w, 0) + 1
-    return freq
-
-
-def caesar_cipher(text: str, shift: int) -> str:
-    """Shift each letter in text by `shift` positions (Caesar cipher). Negative shift decodes."""
-    result = []
-    for ch in text:
-        if ch.isalpha():
-            base = ord('A') if ch.isupper() else ord('a')
-            result.append(chr((ord(ch) - base + shift) % 26 + base))
-        else:
-            result.append(ch)
-    return "".join(result)
-
-
-def reverse_words(text: str) -> str:
-    """Reverse the order of words in a sentence."""
-    return " ".join(text.split()[::-1])