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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.1.1
+Version: 0.2.0
 Summary: Math and string utilities with a bundled CLI
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{quicktools_atom-0.1.1 → quicktools_atom-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quicktools-atom"
-version = "0.1.1"
+version = "0.2.0"
 description = "Math and string utilities with a bundled CLI"
 requires-python = ">=3.9"
 readme = "README.md"

quicktools_atom-0.2.0/src/quicktools/calculus.py

@@ -0,0 +1,65 @@
+"""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

quicktools_atom-0.2.0/src/quicktools/combinatorics.py

@@ -0,0 +1,36 @@
+"""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)]

quicktools_atom-0.2.0/src/quicktools/linalg.py

@@ -0,0 +1,99 @@
+"""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.
+"""
+
+
+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)))

quicktools_atom-0.2.0/src/quicktools/numbertheory.py

@@ -0,0 +1,61 @@
+"""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

quicktools_atom-0.2.0/src/quicktools/strtools.py

@@ -0,0 +1,106 @@
+"""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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.1.1
+Version: 0.2.0
 Summary: Math and string utilities with a bundled CLI
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{quicktools_atom-0.1.1 → quicktools_atom-0.2.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/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])