AxiomX 0.1.2__tar.gz → 0.1.4__tar.gz

axiomx-0.1.4/AxiomX/__init__.py

@@ -0,0 +1,20 @@
+import time
+
+"""
+AxiomX 0.1.4, the pure Python Scientific Math Library.
+
+We have updated a lot and have improved accuracy. Trig Functions are calculated using CORDIC. Also we have updated our graphing system, with zooming, panning and gridlines. If you have any suggestions, email us at axiomx.python@gmail.com. Thank you all for acknowledging AxiomX.
+"""
+
+print("AxiomX loading...")
+time.sleep(3)
+print("AxiomX is ready to use!")
+
+import AxiomX.constants
+import AxiomX.calculus
+import AxiomX.functions
+import AxiomX.exp
+import AxiomX.trig
+import AxiomX.hyperbolic
+
+version = '0.1.0'

{axiomx-0.1.2 → axiomx-0.1.4}/AxiomX/calculus.py

@@ -1,5 +1,13 @@
+"""
+AxiomX.calculus - the calculus module of AxiomX.
+
+AxiomX.calculus helps in doing advanced calculus like evaluating integrals, summations and also does convergence analysis.
+"""
+
+
 # integrating integrals
 def integrate(function, lowlim, uplim, n=10000):
+    """Integrates functions with the help of Simpson's Rule."""
     h = (uplim - lowlim) / n
     s = function(lowlim) + function(uplim)
 
@@ -13,6 +21,7 @@ def integrate(function, lowlim, uplim, n=10000):
     return s * h / 3
     
 def summation(lowlim, uplim, function, max_terms=10**6):
+    """Sums up a function from a given lower limit to an upper limit (also supports infinity)."""
     total = 0
     count = 0
     
@@ -42,6 +51,7 @@ def summation(lowlim, uplim, function, max_terms=10**6):
         return total
         
 def converges(f, tolerance=1e-6, max_terms=10**6):
+    """Check if a given function converges or diverges."""
     total = 0
     prev = 0
     
@@ -57,39 +67,4 @@ def converges(f, tolerance=1e-6, max_terms=10**6):
         
         prev = total
     
-    return False
-    
-def lim(f, xlim, tol=1e-5):
-    # Try direct substitution
-    try:
-        return f(xlim)
-    except ZeroDivisionError:
-        pass  # expected for limits
-    except Exception as e:
-        return None  # or raise e if you want strict behavior
-
-    hs = [1e-1, 1e-2, 1e-3, 1e-4, 1e-5]
-    left_vals = []
-    right_vals = []
-
-    for h in hs:
-        try:
-            left_vals.append(f(xlim - h))
-        except ZeroDivisionError:
-            continue
-
-        try:
-            right_vals.append(f(xlim + h))
-        except ZeroDivisionError:
-            continue
-
-    if not left_vals or not right_vals:
-        return None
-
-    left = left_vals[-1]
-    right = right_vals[-1]
-
-    if abs(left - right) < tol:
-        return (left + right) / 2
-
-    return None
+    return False

axiomx-0.1.4/AxiomX/constants.py

@@ -0,0 +1,69 @@
+"""
+AxiomX.constants - the constants module of AxiomX.
+
+AxiomX provides a large variety of constants, unlike the default math library which contains only pi, e and tau. Our library also contains series of constants like Bernoulli numbers, Stieltjes Numbers, Harmonic numbers, etc.
+"""
+
+from AxiomX.calculus import *
+from AxiomX.functions import *
+from AxiomX.exp import *
+
+pi = 3.141592653589793
+e = 2.718281828459045
+tau = 2*pi
+lemniscate = 2.622057554292119
+gauss = lemniscate / pi
+euler_mascheroni = 0.577215664901533
+sqrt_2 = 2**0.5
+sqrt_3 = 3**0.5
+sqrt_5 = 5**0.5
+golden_ratio = (1 + sqrt_5) / 2
+silver_ratio = 1 + sqrt_2
+gelfond = e**pi
+gelfond_schneider = 2**sqrt_2
+infinity = float("inf")
+
+def metallic_ratio(n):
+    """Returns the metallic ratio of order n."""
+    return (n + (n**2 + 4)**0.5) / 2
+    
+def harmonic_number(n):
+    """Returns the nth Harmonic number."""
+    return summation(1, n, lambda x:1/x)
+    
+def bernoulli(n):
+    """Returns the nth Bernoulli number."""
+    B = [0] * (n + 1)
+    B[0] = 1
+
+    for m in range(1, n + 1):
+        B[m] = 0
+        for k in range(m):
+            B[m] -= (bc(m + 1, k) * B[k])
+        B[m] /= (m + 1)
+
+    if n % 2 == 1:
+        if n == 1:
+            return 0.5
+        return 0.0
+    return B[n]
+    
+from decimal import Decimal, getcontext
+
+def stieltjes(m, N=200000):
+    """Returns the mth Stieltjes number."""
+    if m==0:
+        return euler_mascheroni
+    getcontext().prec = 40  # extra precision buffer
+
+    s = Decimal(0)
+
+    for k in range(1, N+1):
+        kD = Decimal(k)
+        ln = kD.ln()
+        s += (ln**m) / kD
+
+    Nln = Decimal(N).ln()
+    correction = (Nln**(m+1)) / Decimal(m+1)
+
+    return float(+ (s - correction))  # unary + applies rounding

{axiomx-0.1.2 → axiomx-0.1.4}/AxiomX/exp.py

@@ -1,7 +1,17 @@
+"""
+AxiomX.exp - the Exponential and Logarithmic functions module of AxiomX.
+
+The AxiomX.exp module contains exponential and logarithmic functions.
+"""
+
+from AxiomX.constants import *
+
 def exp(n):
+    """Returns e**n, where e = 2.718281828459045."""
     return e**n
 
 def ln(x):
+    """Return the the natural logarithm of x."""
     if x <= 0:
         raise ValueError("ln(x) is undefined for x <= 0")
     k = 0
@@ -23,10 +33,13 @@ def ln(x):
     return 2*s + k * (0.693147180559945309417232121458176568) # ln 2
     
 def log10(x):
+    """Returns the common logarithm of x."""
     return ln(x) / ln(10)
     
 def log2(x):
+    """Returns the binary logarithm of x."""
     return log10(x) / log10(2)
     
-def log(arg, base):
-    return log2(arg) / log2(base)
+def log(x, b):
+    """Returns the logarithm of x to the base b."""
+    return log2(x) / log2(b)

{axiomx-0.1.2 → axiomx-0.1.4}/AxiomX/functions.py

@@ -1,10 +1,17 @@
+from AxiomX.constants import *
+
+"""
+AxiomX.functions - the Arithmetic functions module of AxiomX.
+
+This module contains arithmetic functions like square root, absolute value, cube root, Gamma function, etc.
+"""
+
 def absolute(x):
-    if (x > 0):
-        return x
-    else:
-        return -x
+    """Returns the absolute value of x."""
+    return x if x >= 0 else -x
         
 def sqrt(a, x0=None, tol=1e-30, max_iter=20):
+    """Returns the square root of a by Halley's Method."""
     if a < 0:
         raise ValueError("a must be non-negative")
 
@@ -27,6 +34,7 @@ def sqrt(a, x0=None, tol=1e-30, max_iter=20):
 
 
 def cbrt(N, tolerance=1e-10, max_iterations=1000):
+    """Returns the cube root of N by Newton-Raphson method."""
     x = N / 3.0 if N != 0 else 0.0
     for i in range(max_iterations):
         x_next = x - (x**3 - N) / (3 * x**2)
@@ -36,6 +44,7 @@ def cbrt(N, tolerance=1e-10, max_iterations=1000):
     return x
 
 def gamma(x):
+    """Returns the Gamma function evaluated at x."""
     # Lanczos approximation constants
     p = [
         0.99999999999980993,
@@ -62,8 +71,9 @@ def gamma(x):
     return sqrt(2 * pi) * (x + g + 0.5)**(x + 0.5) * (e**(-(x + g + 0.5))) * t
     
 def factorial(x):
+    """Calculates the factorial of x with the help of Gamma function."""
     if (x // 1 == x):
-        f = 1
+        f = 1.0
         while x > 0:
             f *= x
             x -= 1
@@ -72,22 +82,25 @@ def factorial(x):
         return gamma(x+1)
 
 def zeta(n):
+    """Returns the value of the Riemann Zeta Function evaluated at n."""
     zetval = 0
     if n <= 1:
         raise ValueError("zeta(n) diverges for n <= 1")
-    for _ in range(1, 100001):
+    for _ in range(1, 1000001):
         zetval += (1 / _**n)
     return zetval
     
 def beta(n):
+    """Returns the value of the Dirichlet Beta function evaluated at n."""
     if n == 0:
         return 0.5
     total = 0.0
-    for i in range(100000):
+    for i in range(1000000):
         total += ((-1)**i) / ((2*i + 1)**n)
     return total
     
 def bc(n, k):
+    """Returns the number of n things taken r at a time."""
     if k < 0 or k > n:
         raise ValueError("Binomial coefficient (n k) doesn't work for negative n or k, or if n < k")
     
@@ -100,6 +113,7 @@ def bc(n, k):
     return result
         
 def pascal(row):
+    """Returns a list containing all numbers on that row of the Pascal's Triangle."""
     pr = []
     for i in range(0, row+1):
         pr.append(int(bc(row, i)))

axiomx-0.1.4/AxiomX/graph.py

@@ -0,0 +1,332 @@
+"""
+AxiomX.graph - the graphing module of AxiomX.
+
+This module provides interactive 2D plotting using turtle graphics.
+
+Features
+--------
+- Multiple function plotting
+- Zoom and pan controls
+- Dynamic grid and axis rendering
+- Real-time mouse coordinate tracking
+
+Controls
+--------
+Keyboard:
+    PageUp      → Zoom in
+    PageDown    → Zoom out
+    Arrow keys  → Pan (← ↑ → ↓)
+
+Mouse:
+    Move cursor to see real-time coordinates
+
+Buttons:
+    Zoom In / Zoom Out / Arrow buttons available at bottom
+
+Example
+-------
+>>> import AxiomX.graph import plot
+>>> plot(lambda x: x**2, -10, 10)
+"""
+
+import tkinter as tk
+import turtle
+
+def plot(funcs, start, end, step=0.1, scale=20, limit=1000):
+    """
+    Plot one or more mathematical functions on an interactive graph.
+
+    Parameters
+    ----------
+    funcs : callable or list of callables
+        A function f(x) or list of functions to plot.
+        Example: lambda x: x**2
+    start : float
+        Starting value of x-axis.
+    end : float
+        Ending value of x-axis.
+    step : float, optional
+        Step size for plotting points (default is 0.1).
+    scale : float, optional
+        Zoom level of the graph (default is 20).
+    limit : float, optional
+        Maximum absolute y-value before skipping (prevents overflow).
+
+    Returns
+    -------
+    None
+
+    Features
+    --------
+    - Supports multiple functions with different colors
+    - Infinite-style grid with dynamic tick spacing
+    - Zoom and pan using keyboard or buttons
+    - Displays real-time mouse coordinates
+
+    Controls
+    --------
+    PageUp / PageDown : Zoom in / out
+    Arrow Keys        : Pan graph
+    Mouse Move        : Show coordinates
+
+    Examples
+    --------
+    >>> plot(lambda x: x**2, -10, 10)
+
+    >>> plot([lambda x: x, lambda x: x**2], -5, 5)
+
+    Notes
+    -----
+    - Discontinuous functions (like tan(x)) are handled by skipping large jumps.
+    - Functions returning None or extremely large values are ignored.
+    - Uses turtle graphics internally, so performance may vary for small step sizes.
+    """
+    if not isinstance(funcs, list):
+        funcs = [funcs]
+    
+    turtle.hideturtle()
+    
+    try:
+        turtle.reset()
+    except turtle.Terminator:
+        turtle.Screen()
+
+    screen = turtle.Screen()
+    root = screen._root  # access tk window
+    root.geometry("800x600")
+    root.resizable(False, False)
+    turtle.hideturtle()
+    screen.title("AxiomX Graph")
+    screen.listen()
+
+    t = turtle.Turtle(visible=False)
+    t.speed(0)
+    t.hideturtle()
+
+    turtle.tracer(0, 0)
+
+    state = {"scale": scale,"offset_x": 0,"offset_y": 0}
+
+    def draw():
+        t.clear()
+        scale = state["scale"]
+        t.color("lightgray")
+        xrange = int(400 / state['scale'])
+
+        x_start = int(-xrange - state["offset_x"])
+        x_end   = int(xrange - state["offset_x"])
+
+        for x in range(x_start, x_end):
+            sx = (x + state["offset_x"]) * state["scale"]
+            t.penup()
+            t.goto(sx, -300)
+            t.pendown()
+            t.goto(sx, 300)
+
+        y_range = int(300 / state["scale"])
+        for y in range(-y_range, y_range+1):
+            sy = (y + state["offset_y"]) * state["scale"]
+            t.penup()
+            t.goto(-400, sy)
+            t.pendown()
+            t.goto(400, sy)
+        
+        
+        t.color("black")
+        
+        # ================= AXES =================
+        # X-axis (y = 0)
+        t.penup()
+        t.goto(-400, (0 + state["offset_y"]) * state["scale"])
+        t.pendown()
+        t.goto(400, (0 + state["offset_y"]) * state["scale"])
+
+        # Y-axis (x = 0)
+        t.penup()
+        t.goto((0 + state["offset_x"]) * state["scale"], -300)
+        t.pendown()
+        t.goto((0 + state["offset_x"]) * state["scale"], 300)
+
+        # ================= X TICKS =================
+        # ================= X-AXIS TICKS (INFINITE STYLE) =================
+
+        t.color("black")
+
+        x_range = 400 / state["scale"]
+
+        # dynamic tick spacing (prevents clutter)
+        tick_step = max(1, int((2 * x_range) / 10))
+
+        # start from left visible edge
+        x_tick = int((-x_range - state["offset_x"]) // tick_step) * tick_step
+
+        while x_tick <= (x_range - state["offset_x"]):
+            sx = (x_tick + state["offset_x"]) * state["scale"]
+
+            # Tick mark
+            t.penup()
+            t.goto(sx, state["offset_y"] * state["scale"] - 5)
+            t.pendown()
+            t.goto(sx, state["offset_y"] * state["scale"] + 5)
+
+            # Label
+            t.penup()
+            t.goto(sx, state["offset_y"] * state["scale"] - 20)
+
+            label = "0" if abs(x_tick) < 1e-9 else str(x_tick)
+            t.write(label, align="center", font=("Arial", 8, "normal"))
+
+            x_tick += tick_step
+
+        # ================= Y TICKS =================
+
+        t.color("black")
+
+        y_range = 300 / state["scale"]
+
+        # dynamic spacing
+        y_tick_step = max(1, int((2 * y_range) / 10))
+
+        # start from bottom visible region (WITH offset)
+        y_tick = int((-y_range - state["offset_y"]) // y_tick_step) * y_tick_step
+
+        y_end = (y_range - state["offset_y"])
+
+        while y_tick <= y_end:
+            sy = (y_tick + state["offset_y"]) * state["scale"]
+
+            if abs(y_tick) < 1e-9:
+                y_tick += y_tick_step
+                continue
+
+            # Tick mark
+            t.penup()
+            t.goto((state["offset_x"]) * state["scale"] - 5, sy)
+            t.pendown()
+            t.goto((state["offset_x"]) * state["scale"] + 5, sy)
+
+            # Label
+            t.penup()
+            t.goto((state["offset_x"]) * state["scale"] - 10, sy - 5)
+            t.write(f"{y_tick}", align="right", font=("Arial", 8, "normal"))
+
+            y_tick += y_tick_step
+        # ================= FUNCTIONS =================
+        colors = ["red", "blue", "green", "purple"]
+
+        for i, f in enumerate(funcs):
+            t.color(colors[i % len(colors)])
+            t.penup()
+
+            x = start
+            drawing = False
+
+            while x <= end:
+                try:
+                    y = f(x)
+
+                    if y is None or abs(y) > limit:
+                        raise ValueError
+
+                    sx = (x + state["offset_x"]) * state["scale"]
+                    sy = (y + state["offset_y"]) * state["scale"]
+
+                    if not drawing:
+                        t.goto(sx, sy)
+                        t.pendown()
+                        drawing = True
+                    else:
+                        t.goto(sx, sy)
+
+                except:
+                    t.penup()
+                    drawing = False
+
+                x += step
+
+        turtle.update()
+
+    # ================= ZOOM =================
+    def zoom_in():
+        state["scale"] *= 1.2
+        draw()
+
+    def zoom_out():
+        state["scale"] /= 1.2
+        draw()
+        
+    def pan_left():
+        state["offset_x"] += 1
+        draw()
+
+    def pan_right():
+        state["offset_x"] -= 1
+        draw()
+
+    def pan_up():
+        state["offset_y"] -= 1
+        draw()
+
+    def pan_down():
+        state["offset_y"] += 1
+        draw()
+        
+    # ================= MOUSE COORDINATES =================
+
+    canvas = screen.getcanvas()
+
+    coord_t = turtle.Turtle(visible=False)
+    coord_t.penup()
+    coord_t.color("black")
+
+    def on_mouse_move(event):
+        # Get canvas size
+        width = canvas.winfo_width()
+        height = canvas.winfo_height()
+
+        # Convert screen pixels → turtle coordinates
+        x_screen = event.x - width / 2
+        y_screen = height / 2 - event.y
+
+        # Convert → graph coordinates (VERY IMPORTANT)
+        x_graph = x_screen / state["scale"] - state["offset_x"]
+        y_graph = y_screen / state["scale"] - state["offset_y"]
+
+        show_coords(x_graph, y_graph)
+
+    def show_coords(x, y):
+        coord_t.clear()
+
+        # Display position (top-left corner)
+        coord_t.goto(-380, 260)
+
+        # Round for clean display
+        text = f"x = {x:.3f}, y = {y:.3f}"
+
+        coord_t.write(text, font=("Arial", 10, "normal"))
+
+    # Bind mouse movement
+    canvas.bind("<Motion>", on_mouse_move)
+
+    # Bind keys
+    screen.listen()
+    screen.onkey(zoom_in, "Next")
+    screen.onkey(zoom_out, "Prior")
+    screen.onkey(pan_right, "Right")
+    screen.onkey(pan_left, "Left")
+    screen.onkey(pan_up, "Up")
+    screen.onkey(pan_down, "Down")
+    
+    root = screen._root
+
+    draw()
+    frame = tk.Frame(root)
+    frame.pack(side="bottom")
+
+    tk.Button(frame, text="Zoom In", command=zoom_in).pack(side="left",anchor="ne")
+    tk.Button(frame, text="Zoom Out", command=zoom_out).pack(side="left",anchor="ne")
+    tk.Button(frame, text="←", command=pan_left).pack(side="left",anchor="ne")
+    tk.Button(frame, text="→", command=pan_right).pack(side="left",anchor="ne")
+    tk.Button(frame, text="↑", command=pan_up).pack(side="left",anchor="ne")
+    tk.Button(frame, text="↓", command=pan_down).pack(side="left",anchor="ne")
+    turtle.mainloop()

axiomx-0.1.4/AxiomX/hyperbolic.py

@@ -0,0 +1,56 @@
+"""
+AxiomX.hyperbolic - the hyperbolic function module.
+
+This module contains all hyperbolic functions and their inverses.
+"""
+
+from AxiomX.exp import ln
+from AxiomX.constants import e
+
+def sinh(x):
+    """Returns the hyperbolic sine of x."""
+    return (e**x - e**(-x))/2
+    
+def cosh(x):
+    """Returns the hyperbolic cosine of x."""
+    return (e**x + e**(-x))/2
+    
+def tanh(x):
+    """Returns the hyperbolic tangent of x."""
+    return sinh(x) / cosh(x)
+    
+def coth(x):
+    """Returns the hyperbolic cotangent of x."""
+    return cosh(x) / sinh(x)
+    
+def sech(x):
+    """Returns the hyperbolic secant of x."""
+    return 1 / cosh(x)
+    
+def cosech(x):
+    """Returns the hyperbolic cosecant of x."""
+    return 1 / sinh(x)
+    
+def arcsinh(x):
+    """Returns the inverse hyperbolic sine of x."""
+    return ln(x + (x**2 + 1)**0.5)
+    
+def arccosh(x):
+    """Returns the inverse hyperbolic cosine of x."""
+    return abs(arcsinh((x**2 - 1)**0.5))
+    
+def arccoth(x):
+    """Returns the inverse hyperbolic tangent of x."""
+    return 0.5 * ln((x+1)/(x-1))
+    
+def arctanh(x):
+    """Returns the inverse hyperbolic cotangent of x."""
+    return arccoth(1/x)
+    
+def arcsech(x):
+    """Returns the inverse hyperbolic secant of x."""
+    return arccosh(1/x)
+    
+def arccosech(x):
+    """Returns the inverse hyperbolic cosecant of x."""
+    return arcsinh(1/x)