AxiomX 0.1.0.dev8__tar.gz → 0.1.2__tar.gz

axiomx-0.1.2/AxiomX/calculus.py

@@ -0,0 +1,95 @@
+# integrating integrals
+def integrate(function, lowlim, uplim, n=10000):
+    h = (uplim - lowlim) / n
+    s = function(lowlim) + function(uplim)
+
+    for i in range(1, n):
+        x = lowlim + i * h
+        if i % 2 == 0:
+            s += 2 * function(x)
+        else:
+            s += 4 * function(x)
+
+    return s * h / 3
+    
+def summation(lowlim, uplim, function, max_terms=10**6):
+    total = 0
+    count = 0
+    
+    if uplim == float("inf"):
+        n = lowlim
+        while count < max_terms:
+            try:
+                term = function(n)
+            except ZeroDivisionError:
+                n += 1
+                continue
+            
+            total += term
+            
+            # Stop if terms are negligible
+            if abs(term) < 1e-10:
+                break
+                
+            n += 1
+            count += 1
+        
+        return total
+    
+    else:
+        for n in range(int(lowlim), int(uplim) + 1):
+            total += function(n)
+        return total
+        
+def converges(f, tolerance=1e-6, max_terms=10**6):
+    total = 0
+    prev = 0
+    
+    for n in range(1, max_terms):
+        try:
+            total += f(n)
+        except ZeroDivisionError:
+            continue
+        
+        # Check if partial sum stabilizes
+        if abs(total - prev) < tolerance:
+            return True
+        
+        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

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/AxiomX/constants.py

@@ -1,6 +1,7 @@
 pi = 3.141592653589793
 e = 2.718281828459045
-lemniscate = 2.22057554292119
+tau = 2*pi
+lemniscate = 2.622057554292119
 gauss = lemniscate / pi
 euler_mascheroni = 0.577215664901533
 sqrt_2 = 2**0.5
@@ -10,6 +11,7 @@ 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):
     return (n + (n**2 + 4)**0.5) / 2

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/AxiomX/exp.py

@@ -16,7 +16,7 @@ def ln(x):
     s = 0.0
     term = y
     n = 1
-    while absolute(term) > 1e-17:
+    while abs(term) > 1e-17:
         s += term / n
         term *= y2
         n += 2

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/AxiomX/functions.py

@@ -85,4 +85,22 @@ def beta(n):
     total = 0.0
     for i in range(100000):
         total += ((-1)**i) / ((2*i + 1)**n)
-    return total
+    return total
+    
+def bc(n, k):
+    if k < 0 or k > n:
+        raise ValueError("Binomial coefficient (n k) doesn't work for negative n or k, or if n < k")
+    
+    k = min(k, n - k)  # symmetry optimization
+    result = 1
+    
+    for i in range(1, k + 1):
+        result = result * (n - i + 1) // i
+    
+    return result
+        
+def pascal(row):
+    pr = []
+    for i in range(0, row+1):
+        pr.append(int(bc(row, i)))
+    return pr

axiomx-0.1.2/AxiomX/matrix.py

@@ -0,0 +1,182 @@
+class Matrix:
+    def __str__(self):
+        result = ""
+        for row in self.matrix:
+            result += " ".join(str(x) for x in row) + "\n"
+        return result
+    
+    def __init__(self, rows, columns):
+        self.rows = rows
+        self.columns = columns
+        self.order = (rows,columns)
+        self.matrix = []
+
+        for i in range(rows):
+            row = []
+            for j in range(columns):
+                row.append(0)
+            self.matrix.append(row)
+        
+    @classmethod
+    def from_list(cls, data):
+        rows = len(data)
+        columns = len(data[0]) if rows > 0 else 0
+
+        obj = cls(rows, columns)
+        obj.matrix = data
+        return obj
+        
+    def transpose(self):
+        data = [[self.matrix[i][j] for i in range(self.rows)] for j in range(self.columns)]
+        return Matrix.from_list(data)
+        
+    def zero(self):
+        self.matrix = []
+        self.matrix = [[0 for _ in range(self.columns)] for _ in range(self.rows)]
+
+    def identity(self):
+        self.matrix = []  # reset matrix
+
+        for i in range(self.rows):
+            row = []
+            for j in range(self.columns):
+                if (i!=j):
+                    row.append(0)
+                else:
+                    row.append(1)
+            self.matrix.append(row)
+            
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            i, j = key
+            return self.matrix[i][j]
+        return self.matrix[key]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, tuple):
+            i, j = key
+            self.matrix[i][j] = value
+        else:
+            self.matrix[key] = value
+            
+    def __add__(self, other):
+        if self.rows != other.rows or self.columns != other.columns:
+            raise ValueError("matrices cannot be added")
+
+        data = [
+            [self[i, j] + other[i, j] for j in range(self.columns)]
+            for i in range(self.rows)
+        ]
+
+        return Matrix.from_list(data)
+        
+    def __sub__(self, other):
+        if self.rows != other.rows or self.columns != other.columns:
+            raise ValueError("matrices cannot be added")
+
+        data = [
+            [self[i, j] - other[i, j] for j in range(self.columns)]
+            for i in range(self.rows)
+        ]
+
+        return Matrix.from_list(data)
+        
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return Matrix.from_list([
+                [self[i, j] * other for j in range(self.columns)]
+                for i in range(self.rows)
+            ])
+
+        if self.columns != other.rows:
+            raise ValueError("Matrix dimensions do not match")
+
+        data = [
+            [
+                sum(self[i, k] * other[k, j] for k in range(self.columns))
+                for j in range(other.columns)
+            ]
+            for i in range(self.rows)
+        ]
+
+        return Matrix.from_list(data)
+        
+    def det(self):
+        if self.rows != self.columns:
+            raise ValueError("determinant is only defined for square matrices")
+
+        # 1x1
+        if self.rows == 1:
+            return self[0, 0]
+
+        # 2x2
+        if self.rows == 2:
+            return self[0, 0]*self[1, 1] - self[0, 1]*self[1, 0]
+
+        # nxn (recursive expansion)
+        determinant = 0
+
+        for j in range(self.columns):
+            submatrix = []
+
+            for i in range(1, self.rows):
+                row = []
+                for k in range(self.columns):
+                    if k != j:
+                        row.append(self[i, k])
+                submatrix.append(row)
+
+            sign = (-1) ** j
+            determinant += Matrix.from_list(submatrix).det() * sign * self[0, j]
+        return determinant
+    
+    def _minor(self, i, j):
+        return Matrix.from_list([
+            [self[r, c] for c in range(self.columns) if c != j]
+            for r in range(self.rows) if r != i
+        ])
+        
+    def _cofactor_matrix(self):
+        data = []
+
+        for i in range(self.rows):
+            row = []
+            for j in range(self.columns):
+                minor = self._minor(i, j)
+                sign = (-1) ** (i + j)
+                row.append(sign * minor.det())
+            data.append(row)
+
+        return Matrix.from_list(data)
+        
+    def inverse(self):
+        if self.rows != self.columns:
+            raise ValueError("Inverse only defined for square matrices")
+
+        det = self.det()
+
+        if det == 0:
+            raise ValueError("Matrix is singular (no inverse)")
+
+        # Special case: 1x1
+        if self.rows == 1:
+            return Matrix.from_list([[1 / self[0, 0]]])
+
+        cofactor = self._cofactor_matrix()
+        adjoint = cofactor.transpose()
+
+        # Multiply by 1/det
+        return adjoint*(1 / det)
+        
+    def __truediv__(self, other):
+        return self*other.inverse()
+        
+    def __pow__(self, other):
+        if not isinstance(other, int):
+            raise ValueError("exponent is not a number")
+        else:
+            p = Matrix(self.rows,self.columns)
+            p.identity()
+            for i in range(other):
+                p *= self
+            return p

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/AxiomX/trig.py

@@ -1,3 +1,6 @@
+from AxiomX.constants import *
+from AxiomX.functions import *
+
 def radians(deg):
     return (pi/180)*deg
     
@@ -18,7 +21,6 @@ def sin(x, terms=20):
     for n in range(terms):
         term = ((-1)**n) * (x**(2*n + 1)) / factorial(2*n + 1)
         sine_value += term
-    return sine_value
     if quarter == 1:
         return sine_value
     elif quarter == 2:
@@ -32,15 +34,23 @@ def cos(x):
     return sin((pi/2)-x)
     
 def tan(x):
+    if cos(x) == 0:
+        return float("inf")
     return sin(x) / cos(x)
 
 def cot(x):
+    if tan(x) == 0:
+        return float("inf")
     return 1 / tan(x)
 
 def sec(x):
+    if cos(x) == 0:
+        return float("inf")
     return 1 / cos(x)
     
 def cosec(x):
+    if sin(x) == 0:
+        return float("inf")
     return 1 / sin(x)
 
 def arcsin(x, iterations=10):
@@ -48,6 +58,8 @@ def arcsin(x, iterations=10):
         raise ValueError("x must be in [-1, 1]")
     y = x
     for _ in range(iterations):
+        if cos(y) == 0:
+            break
         y -= (sin(y) - x) / cos(y)
     return y
     
@@ -61,7 +73,11 @@ def arccot(x):
     return (pi/2) - arctan(x)
 
 def arcsec(x):
+    if x < 1:
+        raise ValueError("x < 1")
     return arccos(1/x)
     
 def arccosec(x):
+    if x < 1:
+        raise ValueError("x < 1")
     return arcsin(1/x)

axiomx-0.1.2/AxiomX.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: AxiomX
+Version: 0.1.2
+Summary: A dynamic Python math library containing numerous mathematical functions implemented from scratch.
+Author: Eric Joseph
+License: MIT
+Requires-Python: >=2.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🔢 AxiomX
+
+**AxiomX** is a lightweight, pure-Python mathematical library built from
+first principles --- designed for accuracy, learning, and mathematical
+exploration.
+
+------------------------------------------------------------------------
+
+## 📢 Community
+
+Join Discord for updates and feature requests. Join [here](https://discord.gg/CrEf8mDB).
+
+------------------------------------------------------------------------
+
+## 🚀 Features
+
+### 📐 Core Mathematics
+
+-   Constants (π, e, φ, √2, γ, ...)
+-   Custom implementations
+
+### 📈 Exponential & Logarithmic
+
+-   exp(x)
+-   ln(x)
+-   log10(x)
+-   log2(x)
+-   log(arg, base)
+
+### 📐 Trigonometry
+
+-   sin, cos, tan, cot, sec, cosec
+-   inverse functions
+
+### 🔢 Hyperbolic Functions
+
+-   sinh, cosh, tanh, coth
+
+### 🧮 General Functions
+
+-   absolute(x)
+-   sqrt(x)
+-   gamma(x)
+-   cbrt(x)
+-   zeta(n) and beta(n)
+
+### ∫ Calculus
+
+-   Numerical integration
+-   summation
+-   convergence analysis
+-   limit evaluation
+
+------------------------------------------------------------------------
+
+## 🧱 Matrix Engine (NEW)
+
+-   Matrix creation
+-   A\[i, j\] access
+-   Addition, subtraction, multiplication by using actual mathematical operators.
+-   Transpose
+-   Determinant
+-   Inverse
+-   Division (via inverse) by using / operator
+
+If you want to create a zero matrix or identity of any order, you can do it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix(x,y) # you can put your values in place of x and y.
+a.zero() # for zero matrix
+a.identity() # for identity matrix.
+```
+
+If you want to create a matrix, from a list, you can try it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix.from_list([]) # enter your matrix in it.
+```
+------------------------------------------------------------------------
+
+## 📦 Installation
+
+`pip install axiomx`
+
+------------------------------------------------------------------------
+
+## ▶️ Usage
+```
+from AxiomX.matrix import Matrix
+
+A = Matrix.from_list(\[\[1, 2\], \[3, 4\]\]) print(A.det())
+```
+
+------------------------------------------------------------------------
+
+## 🧠 Philosophy
+
+Accuracy \> Speed
+
+------------------------------------------------------------------------
+
+## 🌐 Website
+
+https://axiomxpy.wordpress.com
+
+------------------------------------------------------------------------
+
+## 🛣️ Roadmap
+
+-   Advanced linear algebra
+-   Series & constants
+
+------------------------------------------------------------------------
+
+## 📜 License
+
+MIT License

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/AxiomX.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ AxiomX/constants.py
 AxiomX/exp.py
 AxiomX/functions.py
 AxiomX/hyperbolic.py
+AxiomX/matrix.py
 AxiomX/trig.py
 AxiomX.egg-info/PKG-INFO
 AxiomX.egg-info/SOURCES.txt

axiomx-0.1.2/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: AxiomX
+Version: 0.1.2
+Summary: A dynamic Python math library containing numerous mathematical functions implemented from scratch.
+Author: Eric Joseph
+License: MIT
+Requires-Python: >=2.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🔢 AxiomX
+
+**AxiomX** is a lightweight, pure-Python mathematical library built from
+first principles --- designed for accuracy, learning, and mathematical
+exploration.
+
+------------------------------------------------------------------------
+
+## 📢 Community
+
+Join Discord for updates and feature requests. Join [here](https://discord.gg/CrEf8mDB).
+
+------------------------------------------------------------------------
+
+## 🚀 Features
+
+### 📐 Core Mathematics
+
+-   Constants (π, e, φ, √2, γ, ...)
+-   Custom implementations
+
+### 📈 Exponential & Logarithmic
+
+-   exp(x)
+-   ln(x)
+-   log10(x)
+-   log2(x)
+-   log(arg, base)
+
+### 📐 Trigonometry
+
+-   sin, cos, tan, cot, sec, cosec
+-   inverse functions
+
+### 🔢 Hyperbolic Functions
+
+-   sinh, cosh, tanh, coth
+
+### 🧮 General Functions
+
+-   absolute(x)
+-   sqrt(x)
+-   gamma(x)
+-   cbrt(x)
+-   zeta(n) and beta(n)
+
+### ∫ Calculus
+
+-   Numerical integration
+-   summation
+-   convergence analysis
+-   limit evaluation
+
+------------------------------------------------------------------------
+
+## 🧱 Matrix Engine (NEW)
+
+-   Matrix creation
+-   A\[i, j\] access
+-   Addition, subtraction, multiplication by using actual mathematical operators.
+-   Transpose
+-   Determinant
+-   Inverse
+-   Division (via inverse) by using / operator
+
+If you want to create a zero matrix or identity of any order, you can do it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix(x,y) # you can put your values in place of x and y.
+a.zero() # for zero matrix
+a.identity() # for identity matrix.
+```
+
+If you want to create a matrix, from a list, you can try it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix.from_list([]) # enter your matrix in it.
+```
+------------------------------------------------------------------------
+
+## 📦 Installation
+
+`pip install axiomx`
+
+------------------------------------------------------------------------
+
+## ▶️ Usage
+```
+from AxiomX.matrix import Matrix
+
+A = Matrix.from_list(\[\[1, 2\], \[3, 4\]\]) print(A.det())
+```
+
+------------------------------------------------------------------------
+
+## 🧠 Philosophy
+
+Accuracy \> Speed
+
+------------------------------------------------------------------------
+
+## 🌐 Website
+
+https://axiomxpy.wordpress.com
+
+------------------------------------------------------------------------
+
+## 🛣️ Roadmap
+
+-   Advanced linear algebra
+-   Series & constants
+
+------------------------------------------------------------------------
+
+## 📜 License
+
+MIT License

axiomx-0.1.2/README.md

@@ -0,0 +1,121 @@
+# 🔢 AxiomX
+
+**AxiomX** is a lightweight, pure-Python mathematical library built from
+first principles --- designed for accuracy, learning, and mathematical
+exploration.
+
+------------------------------------------------------------------------
+
+## 📢 Community
+
+Join Discord for updates and feature requests. Join [here](https://discord.gg/CrEf8mDB).
+
+------------------------------------------------------------------------
+
+## 🚀 Features
+
+### 📐 Core Mathematics
+
+-   Constants (π, e, φ, √2, γ, ...)
+-   Custom implementations
+
+### 📈 Exponential & Logarithmic
+
+-   exp(x)
+-   ln(x)
+-   log10(x)
+-   log2(x)
+-   log(arg, base)
+
+### 📐 Trigonometry
+
+-   sin, cos, tan, cot, sec, cosec
+-   inverse functions
+
+### 🔢 Hyperbolic Functions
+
+-   sinh, cosh, tanh, coth
+
+### 🧮 General Functions
+
+-   absolute(x)
+-   sqrt(x)
+-   gamma(x)
+-   cbrt(x)
+-   zeta(n) and beta(n)
+
+### ∫ Calculus
+
+-   Numerical integration
+-   summation
+-   convergence analysis
+-   limit evaluation
+
+------------------------------------------------------------------------
+
+## 🧱 Matrix Engine (NEW)
+
+-   Matrix creation
+-   A\[i, j\] access
+-   Addition, subtraction, multiplication by using actual mathematical operators.
+-   Transpose
+-   Determinant
+-   Inverse
+-   Division (via inverse) by using / operator
+
+If you want to create a zero matrix or identity of any order, you can do it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix(x,y) # you can put your values in place of x and y.
+a.zero() # for zero matrix
+a.identity() # for identity matrix.
+```
+
+If you want to create a matrix, from a list, you can try it this way:
+
+```
+from AxiomX.matrix import Matrix
+
+a = Matrix.from_list([]) # enter your matrix in it.
+```
+------------------------------------------------------------------------
+
+## 📦 Installation
+
+`pip install axiomx`
+
+------------------------------------------------------------------------
+
+## ▶️ Usage
+```
+from AxiomX.matrix import Matrix
+
+A = Matrix.from_list(\[\[1, 2\], \[3, 4\]\]) print(A.det())
+```
+
+------------------------------------------------------------------------
+
+## 🧠 Philosophy
+
+Accuracy \> Speed
+
+------------------------------------------------------------------------
+
+## 🌐 Website
+
+https://axiomxpy.wordpress.com
+
+------------------------------------------------------------------------
+
+## 🛣️ Roadmap
+
+-   Advanced linear algebra
+-   Series & constants
+
+------------------------------------------------------------------------
+
+## 📜 License
+
+MIT License

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AxiomX"
-version = "0.1.0.dev8"
+version = "0.1.2"
 authors = [
     { name = "Eric Joseph" }
 ]

{axiomx-0.1.0.dev8 → axiomx-0.1.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="AxiomX",  # rename to your project name
-    version="0.1.0.dev8",
+    version="0.1.2",
     description="A custom Python math library with special functions.",
     author="Eric Joseph",  # change if needed
     packages=find_packages(),

axiomx-0.1.0.dev8/AxiomX/calculus.py

@@ -1,60 +0,0 @@
-# integrating integrals
-def integrate(function, lowlim, uplim, n=10000):
-    h = (uplim - lowlim) / n
-    s = function(lowlim) + function(uplim)
-
-    for i in range(1, n):
-        x = lowlim + i * h
-        if i % 2 == 0:
-            s += 2 * function(x)
-        else:
-            s += 4 * function(x)
-
-    return s * h / 3
-    
-def summation(lowlim, uplim, function):
-    sum = 0
-    for _ in range(lowlim, uplim + 1):
-        sum += function(_)
-    return sum
-
-def converges(f):
-    if (f(2) == 0.5):
-        return False
-    try:
-        n1 = 10**5
-        n2 = 10**6
-
-        a1 = abs(f(n1))
-        a2 = abs(f(n2))
-
-        # 1) nth-term test (stronger)
-        if a2 > 1e-3:
-            return False
-
-        # 2) Ratio test
-        if a1 != 0:
-            L = abs(a2 / a1)
-            if L < 0.9:
-                return True
-            if L > 1.1:
-                return False
-
-        # 3) Alternating test
-        if f(1000) * f(1001) < 0 and a2 < a1:
-            return "Conditional"
-
-        # 4) Partial sum growth test
-        S1 = sum(f(n) for n in range(1,2000))
-        S2 = sum(f(n) for n in range(1,4000))
-
-        if abs(S2) > abs(S1) * 1.2:
-            return False
-
-        if abs(S2 - S1) < 1e-3:
-            return True
-
-    except:
-        return "Inconclusive"
-
-    return "Inconclusive"

axiomx-0.1.0.dev8/AxiomX.egg-info/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.4
-Name: AxiomX
-Version: 0.1.0.dev8
-Summary: A dynamic Python math library containing numerous mathematical functions implemented from scratch.
-Author: Eric Joseph
-License: MIT
-Requires-Python: >=2.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-Dynamic: requires-python
-
-# AxiomX 0.1.0.dev8
-
-AxiomX is proud to release the 0.1.0.dev8 bugfix release. We're extremely sorry for the inconvenience we have caused. We had realized about a bug running in our module. We have fixed it and as this is a bugfix release, we have not added anything new.
-\
-\
-This module is licensed under MIT. No one is allowed to copy code from AxiomX. Hope you all enjoy AxiomX.

axiomx-0.1.0.dev8/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.4
-Name: AxiomX
-Version: 0.1.0.dev8
-Summary: A dynamic Python math library containing numerous mathematical functions implemented from scratch.
-Author: Eric Joseph
-License: MIT
-Requires-Python: >=2.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-Dynamic: requires-python
-
-# AxiomX 0.1.0.dev8
-
-AxiomX is proud to release the 0.1.0.dev8 bugfix release. We're extremely sorry for the inconvenience we have caused. We had realized about a bug running in our module. We have fixed it and as this is a bugfix release, we have not added anything new.
-\
-\
-This module is licensed under MIT. No one is allowed to copy code from AxiomX. Hope you all enjoy AxiomX.

axiomx-0.1.0.dev8/README.md

@@ -1,6 +0,0 @@
-# AxiomX 0.1.0.dev8
-
-AxiomX is proud to release the 0.1.0.dev8 bugfix release. We're extremely sorry for the inconvenience we have caused. We had realized about a bug running in our module. We have fixed it and as this is a bugfix release, we have not added anything new.
-\
-\
-This module is licensed under MIT. No one is allowed to copy code from AxiomX. Hope you all enjoy AxiomX.