hypermath-Kavyansh-Arya 0.2.0__py3-none-any.whl

HyperMath.py

@@ -0,0 +1,602 @@
+
+class factorial:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Factorial is not defined for negative numbers.")
+        elif self.n == 0 or self.n == 1:
+            return 1
+        else:
+            result = 1
+            for i in range(2, self.n + 1):
+                result *= i
+            return result
+class double_factorial:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Double factorial is not defined for negative numbers.")
+        elif self.n == 0 or self.n == 1:
+            return 1
+        else:
+            result = 1
+            for i in range(self.n, 0, -2):
+                result *= i
+            return result
+class square_root:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Square root is not defined for negative numbers.")
+        return self.n ** 0.5
+class superfactorial(factorial):
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Superfactorial is not defined for negative numbers.")
+        elif self.n == 0 or self.n == 1:
+            return 1
+        else:
+            result = 1
+            for i in range(1, self.n + 1):
+                result *= factorial(i).calculate()
+            return result
+class exponentiation:
+    def __init__(self, base, exponent):
+        self.base = base
+        self.exponent = exponent
+
+    def calculate(self):
+        return self.base ** self.exponent
+class successor:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        return self.n + 1
+class tetration:
+    def __init__(self, base, height):
+        self.base = base
+        self.height = height
+
+    def calculate(self):
+        if self.height < 0:
+            raise ValueError("Tetration is not defined for negative heights.")
+        elif self.height == 0:
+            return 1
+        else:
+            result = self.base
+            for _ in range(1, self.height):
+                result = self.base ** result
+            return result
+class pentation:
+    def __init__(self, base, height):
+        self.base = base
+        self.height = height
+
+    def calculate(self):
+        if self.height < 0:
+            raise ValueError("Pentation is not defined for negative heights.")
+        elif self.height == 0:
+            return 1
+        else:
+            result = self.base
+            for _ in range(1, self.height):
+                result = tetration(self.base, result).calculate()
+            return result
+class complex_number:
+    def __init__(self, real, imaginary):
+        self.real = real
+        self.imaginary = imaginary
+
+    def calculate(self):
+        return complex(self.real, self.imaginary)
+class logarithm:
+    def __init__(self, base, value):
+        self.base = base
+        self.value = value
+
+    def calculate(self):
+        if self.base <= 0 or self.base == 1:
+            raise ValueError("Logarithm base must be positive and not equal to 1.")
+        if self.value <= 0:
+            raise ValueError("Logarithm value must be positive.")
+        import math
+        return math.log(self.value, self.base)
+class constants:
+    def __init__(self):
+        self.pi = 3.141592653589793
+        self.e = 2.718281828459045
+        self.phi = 1.618033988749895
+
+    def get_constant(self, name):
+        if name == "pi":
+            return self.pi
+        elif name == "e":
+            return self.e
+        elif name == "phi":
+            return self.phi
+        else:
+            raise ValueError("Unknown constant name.")
+class arithmetic_operations:
+    def add(self, a, b):
+        return a + b
+
+    def subtract(self, a, b):
+        return a - b
+
+    def multiply(self, a, b):
+        return a * b
+
+    def divide(self, a, b):
+        if b == 0:
+            raise ValueError("Division by zero is not allowed.")
+        return a / b
+class trigonometric_functions:
+    def sine(self, angle):
+        import math
+        return math.sin(angle)
+
+    def cosine(self, angle):
+        import math
+        return math.cos(angle)
+
+    def tangent(self, angle):
+        import math
+        return math.tan(angle)
+class hexation:
+    def __init__(self, base, height):
+        self.base = base
+        self.height = height
+
+    def calculate(self):
+        if self.height < 0:
+            raise ValueError("Hexation is not defined for negative heights.")
+        elif self.height == 0:
+            return 1
+        else:
+            result = self.base
+            for _ in range(1, self.height):
+                result = pentation(self.base, result).calculate()
+            return result
+class limit:
+    def __init__(self, function, variable, approach):
+        self.function = function
+        self.variable = variable
+        self.approach = approach
+
+    def calculate(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        limit_value = sp.limit(self.function, x, self.approach)
+        return limit_value
+class derivative:
+    def __init__(self, function, variable):
+        self.function = function
+        self.variable = variable
+
+    def calculate(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        derivative_value = sp.diff(self.function, x)
+        return derivative_value
+class integral:
+    def __init__(self, function, variable):
+        self.function = function
+        self.variable = variable
+
+    def calculate(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        integral_value = sp.integrate(self.function, x)
+        return integral_value
+class quadratic_equation:
+    def __init__(self, a, b, c):
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def calculate(self):
+        import math
+        discriminant = self.b ** 2 - 4 * self.a * self.c
+        if discriminant < 0:
+            raise ValueError("No real roots exist.")
+        root1 = (-self.b + math.sqrt(discriminant)) / (2 * self.a)
+        root2 = (-self.b - math.sqrt(discriminant)) / (2 * self.a)
+        return root1, root2
+class uncommon_constants:
+    def __init__(self):
+        self.constants = {
+            "golden_ratio": 1.618033988749895,
+            "euler_mascheroni": 0.577215664901532,
+            "aperys_constant": 1.202056903159594,
+            "catalans_constant": 0.915965594177219,
+            "khinchin_constant": 2.685452001065306
+        }
+
+    def get_constant(self, name):
+        if name in self.constants:
+            return self.constants[name]
+        else:
+            raise ValueError("Unknown constant name.")
+class decimal_exponent:
+    def __init__(self, base, exponent):
+        self.base = base
+        self.exponent = exponent
+
+    def calculate(self):
+        return self.base ** self.exponent
+
+        return result
+class hyperfactorial:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Hyperfactorial is not defined for negative numbers.")
+        result = 1
+        for i in range(1, self.n + 1):
+            result *= i ** i
+        return result
+class predecessor:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        return self.n - 1
+
+class complex_exponentiation:
+    def __init__(self, base, exponent):
+        self.base = base
+        self.exponent = exponent
+
+    def calculate(self):
+        return self.base ** self.exponent
+
+
+class paradoxes:
+    def __init__(self):
+        self.paradoxes = {
+            "liars_paradox": "This statement is false.",
+            "barbers_paradox": "The barber is the one who shaves all those, and those only, who do not shave themselves.",
+            "russells_paradox": "The set of all sets that do not contain themselves.",
+            "achilles_and_tortoise": "Achilles can never overtake the tortoise in a race if the tortoise has a head start.",
+            "grandfather_paradox": "If you travel back in time and kill your grandfather, you would never have been born to go back in time."
+        }
+
+    def get_paradox(self, name):
+        if name in self.paradoxes:
+            return self.paradoxes[name]
+        else:
+            raise ValueError("Unknown paradox name.")
+class inequality_solver:
+    def __init__(self, inequality, variable):
+        self.inequality = inequality
+        self.variable = variable
+
+    def solve(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        solution = sp.solve_univariate_inequality(self.inequality, x)
+        return solution
+class identity_matrix:
+    def __init__(self, size):
+        self.size = size
+
+    def generate(self):
+        import numpy as np
+        return np.identity(self.size)
+class computer_number_system:
+    def __init__(self, number, base):
+        self.number = number
+        self.base = base
+
+    def convert(self):
+        if self.base < 2 or self.base > 36:
+            raise ValueError("Base must be between 2 and 36.")
+        if self.number < 0:
+            raise ValueError("Number must be non-negative.")
+        digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        result = ""
+        n = self.number
+        while n > 0:
+            result = digits[n % self.base] + result
+            n //= self.base
+        return result if result else "0"
+class nth_root:
+    def __init__(self, n, root):
+        self.n = n
+        self.root = root
+
+    def calculate(self):
+        if self.root <= 0:
+            raise ValueError("Root must be positive.")
+        return self.n ** (1 / self.root)
+class calculus:
+    def __init__(self, function, variable):
+        self.function = function
+        self.variable = variable
+
+    def differentiate(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        derivative_value = sp.diff(self.function, x)
+        return derivative_value
+
+    def integrate(self):
+        import sympy as sp
+        x = sp.symbols(self.variable)
+        integral_value = sp.integrate(self.function, x)
+        return integral_value
+class fibonacci:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Fibonacci is not defined for negative numbers.")
+        elif self.n == 0:
+            return 0
+        elif self.n == 1:
+            return 1
+        else:
+            a, b = 0, 1
+            for _ in range(2, self.n + 1):
+                a, b = b, a + b
+            return b
+class tribonacci:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Tribonacci is not defined for negative numbers.")
+        elif self.n == 0:
+            return 0
+        elif self.n == 1 or self.n == 2:
+            return 1
+        else:
+            a, b, c = 0, 1, 1
+            for _ in range(3, self.n + 1):
+                a, b, c = b, c, a + b + c
+            return c
+class tetranacci:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        if self.n < 0:
+            raise ValueError("Tetranacci is not defined for negative numbers.")
+        elif self.n == 0:
+            return 0
+        elif self.n == 1 or self.n == 2:
+            return 1
+        elif self.n == 3:
+            return 2
+        else:
+            a, b, c, d = 0, 1, 1, 2
+            for _ in range(4, self.n + 1):
+                a, b, c, d = b, c, d, a + b + c + d
+            return d
+
+class round_up:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        import math
+        return math.ceil(self.n)
+class round_down:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        import math
+        return math.floor(self.n)
+class round_nearest:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        import math
+        return round(self.n)
+class absolute_value:
+    def __init__(self, n):
+        self.n = n
+
+    def calculate(self):
+        return abs(self.n)
+class tensor_product:
+    def __init__(self, A, B):
+        self.A = A
+        self.B = B
+
+    def calculate(self):
+        import numpy as np
+        return np.kron(self.A, self.B)
+class lie_bracket:
+    def __init__(self, A, B):
+        self.A = A
+        self.B = B
+
+    def calculate(self):
+        import numpy as np
+        return np.dot(self.A, self.B) - np.dot(self.B, self.A)
+class pi_finder:
+    def __init__(self, iterations, precision=100):
+        if iterations < 1:
+            raise ValueError("Iterations must be at least 1.")
+        if precision < 1:
+            raise ValueError("Precision must be at least 1.")
+
+        self.iterations = iterations
+        self.precision = precision
+
+    def calculate(self):
+        from decimal import Decimal, getcontext
+
+        getcontext().prec = self.precision
+
+        C = Decimal(426880) * Decimal(10005).sqrt()
+
+        K = 6
+        M = 1
+        X = 1
+        L = 13591409
+        S = Decimal(L)
+
+        for i in range(1, self.iterations):
+            M = (K**3 - 16 * K) * M // (i**3)
+            L += 545140134
+            X *= -262537412640768000
+
+            S += Decimal(M * L) / Decimal(X)
+
+            K += 12
+
+        return C / S
+
+class gamma:
+    def __init__(self, value):
+        if value <= -1 and value == int(value):
+            raise ValueError("Factorial is undefined for negative integers.")
+
+        self.value = value
+
+    def calculate(self):
+        import math
+        return math.gamma(self.value + 1)
+class unit_covertor:
+    def __init__(self, value, from_unit, to_unit):
+        self.value = value
+        self.from_unit = from_unit
+        self.to_unit = to_unit
+
+    def convert(self):
+        conversion_factors = {
+            "m_to_km": 0.001,
+            "km_to_m": 1000,
+            "cm_to_m": 0.01,
+            "m_to_cm": 100,
+            "in_to_cm": 2.54,
+            "cm_to_in": 1 / 2.54,
+            "ft_to_m": 0.3048,
+            "m_to_ft": 1 / 0.3048,
+            "lb_to_kg": 0.45359237,
+            "kg_to_lb": 1 / 0.45359237,
+            "oz_to_g": 28.3495,
+            "g_to_oz": 1 / 28.3495,
+            "l_to_ml": 1000,
+            "ml_to_l": 0.001,
+            "gal_to_l": 3.78541,
+            "l_to_gal": 1 / 3.78541,
+            "mi_to_km": 1.60934,
+            "km_to_mi": 1 / 1.60934,
+            "yd_to_m": 0.9144,
+            "m_to_yd": 1 / 0.9144,
+            "ft_to_in": 12,
+            "in_to_ft": 1 / 12,
+            "mi_to_ft": 5280,
+            "ft_to_mi": 1 / 5280,
+            "rad_to_deg": 180 / 3.141592653589793,
+            "deg_to_rad": 3.141592653589793 / 180,
+            "c_to_f": lambda c: (c * 9 / 5) + 32,
+            "f_to_c": lambda f: (f - 32) * 5 / 9,
+            "k_to_c": lambda k: k - 273.15,
+            "c_to_k": lambda c: c + 273.15,
+            "f_to_k": lambda f: (f - 32) * 5 / 9 + 273.15,
+            "k_to_f": lambda k: (k - 273.15) * 9 / 5 + 32,
+            "kms_to_mph": 0.621371,
+            "mph_to_kms": 1 / 0.621371,
+        }
+
+        key = f"{self.from_unit}_to_{self.to_unit}"
+        if key not in conversion_factors:
+            raise ValueError("Conversion not supported.")
+
+        return self.value * conversion_factors[key]
+class prime_checker:
+    def __init__(self, n):
+        self.n = n
+
+    def is_prime(self):
+        if self.n <= 1:
+            return False
+        for i in range(2, int(self.n ** 0.5) + 1):
+            if self.n % i == 0:
+                return False
+        return True
+class prime_generator:
+    def __init__(self, limit):
+        self.limit = limit
+
+    def generate_primes(self):
+        primes = []
+        for num in range(2, self.limit + 1):
+            is_prime = True
+            for i in range(2, int(num ** 0.5) + 1):
+                if num % i == 0:
+                    is_prime = False
+                    break
+            if is_prime:
+                primes.append(num)
+        return primes
+class prime_factorization:
+    def __init__(self, n):
+        self.n = n
+
+    def factorize(self):
+        factors = []
+        num = self.n
+        for i in range(2, int(num ** 0.5) + 1):
+            while num % i == 0:
+                factors.append(i)
+                num //= i
+        if num > 1:
+            factors.append(num)
+        return factors
+class identites:
+    def __init__(self):
+        self.identities = {
+            "pythagorean": "a^2 + b^2 = c^2",
+            "trig": "sin^2(x) + cos^2(x) = 1",
+            "logarithmic": "log_b(xy) = log_b(x) + log_b(y)",
+            "exponential": "e^(x+y) = e^x * e^y",
+            "binomial": "(a+b)^n = sum(k=0 to n) C(n,k) * a^(n-k) * b^k"
+        }
+
+    def get_identity(self, name):
+        if name in self.identities:
+            return self.identities[name]
+        else:
+            raise ValueError("Unknown identity name.")
+class pythagoras_theory:
+    def __init__(self, a=None, b=None, c=None):
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def calculate_missing_side(self):
+        if self.c is None:
+            if self.a is not None and self.b is not None:
+                return (self.a ** 2 + self.b ** 2) ** 0.5
+            else:
+                raise ValueError("Insufficient information to calculate hypotenuse.")
+        elif self.a is None:
+            if self.c is not None and self.b is not None:
+                return (self.c ** 2 - self.b ** 2) ** 0.5
+            else:
+                raise ValueError("Insufficient information to calculate side a.")
+        elif self.b is None:
+            if self.c is not None and self.a is not None:
+                return (self.c ** 2 - self.a ** 2) ** 0.5
+            else:
+                raise ValueError("Insufficient information to calculate side b.")
+        else:
+            raise ValueError("All sides are already provided.")

hypermath_kavyansh_arya-0.2.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: hypermath-Kavyansh-Arya
+Version: 0.2.0
+Summary: A custom math module for factorials, roots, and advanced operations.
+Author: Kavyansh N Arya
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+It is a custom python module to implement advance mathematical calculation and have different constants like pi, Euler number, golden ratio and more
+NOTICE:
+It requires at least Python 3.0 otherwise it will not work or not even install.

hypermath_kavyansh_arya-0.2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+HyperMath.py,sha256=fxeosrC47zZT023DtkYFeIJQ-FNpznd1jvIApWb-0v8,18399
+hypermath_kavyansh_arya-0.2.0.dist-info/METADATA,sha256=xnpkQmdUQQi1XVypcdCPjr3kK7QTHAaUDMJiLLubPjU,631
+hypermath_kavyansh_arya-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hypermath_kavyansh_arya-0.2.0.dist-info/top_level.txt,sha256=bOavEwrIQ7y0eP_Vz1iSZuHeLoAuATdZB3yj8G6gnbg,10
+hypermath_kavyansh_arya-0.2.0.dist-info/RECORD,,

hypermath_kavyansh_arya-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hypermath_kavyansh_arya-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+HyperMath