derivative-utils 0.1.0__tar.gz

derivative_utils-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: derivative-utils
+Version: 0.1.0
+Summary: [alpha] Tools for computing and working with derivatives of functions.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# derivative-utils [alpha]
+A simple package for working with derivatives.
+This is in alpha, and may not work as intended.

derivative_utils-0.1.0/README.md

@@ -0,0 +1,3 @@
+# derivative-utils [alpha]
+A simple package for working with derivatives.
+This is in alpha, and may not work as intended.

derivative_utils-0.1.0/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "derivative-utils"
+version = "0.1.0"
+description = "[alpha] Tools for computing and working with derivatives of functions."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = []

derivative_utils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

derivative_utils-0.1.0/src/__init__.py

@@ -0,0 +1,28 @@
+from expressions import *
+from dat import *
+def differentiate(func):
+  if type(func) == MainVariable: return Number(1)
+  elif type(func) == Quotient:
+    return Quotient(Difference(Product(differentiate(func.a), func.b),Product(differentiate(func.b), func.a)),Exponent(func.b,2))
+  elif type(func) == Product:
+    if type(func.a) != Number and type(func.a) != Number: return Sum(Product(differentiate(func.a), func.b),Product(differentiate(func.b), func.a))
+    elif type(func.a) != Number: return Product(differentiate(func.a), func.b)
+    elif type(func.b) != Number: return Product(differentiate(func.b), func.a)
+  elif type(func) == Sum: return Sum(differentiate(func.a), differentiate(func.b))
+  elif type(func) == Difference: return Difference(differentiate(func.a), differentiate(func.b))
+  elif type(func) == Exponent:
+    if type(func.x) != Number and type(func.exp) != Number:
+      return differentiate(Exponent())
+    elif type(func.x) != Number: return simplify(Product(differentiate(func.x), Product(func.exp, Exponent(func.x, func.exp - 1))))
+    elif type(func.exp) != Number: return simplify(Product(StdFunction("ln").eval(func.x), Product(differentiate(func.exp), func)))
+    else: return Number(0)
+  elif type(func) == StdFunction:
+    return simplify(Product(differentiate(func.val), func.derivative(func.val)))
+  elif type(func) == MainVariable:
+    return Number(1)
+  elif type(func) == Number: return Number(0)
+  elif type(func) == Polynomial:
+    coeff = func.coeff[:]
+    coeff.pop()
+    coeff = [c*(len(coeff)-i) for i,c in enumerate(coeff)]
+    return Polynomial(coeff)

derivative_utils-0.1.0/src/const.py

@@ -0,0 +1,2 @@
+pi = 3.141592653589793238462643383279502884197169
+e  = 2.718281828459045235360287471352662497757247

derivative_utils-0.1.0/src/dat.py

@@ -0,0 +1,16 @@
+import json
+class Table:
+  def __init__(self, x, y):
+    self.x = x
+    self.y = y
+  def display(self):
+    pass
+  def json(self):
+    return json.dumps({"x":self.x, "y": self.y})
+  def obj(self):
+    return {"x":self.x, "y": self.y}
+def table(expression, xL:list):
+  yL = []
+  for x in xL:
+    yL.append(expression.eval(x))
+  return Table(xL, yL)

derivative_utils-0.1.0/src/derivative_utils.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: derivative-utils
+Version: 0.1.0
+Summary: [alpha] Tools for computing and working with derivatives of functions.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# derivative-utils [alpha]
+A simple package for working with derivatives.
+This is in alpha, and may not work as intended.

derivative_utils-0.1.0/src/derivative_utils.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/__init__.py
+src/const.py
+src/dat.py
+src/exceptions.py
+src/expressions.py
+src/func.py
+src/util.py
+src/derivative_utils.egg-info/PKG-INFO
+src/derivative_utils.egg-info/SOURCES.txt
+src/derivative_utils.egg-info/dependency_links.txt
+src/derivative_utils.egg-info/top_level.txt

derivative_utils-0.1.0/src/derivative_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

derivative_utils-0.1.0/src/derivative_utils.egg-info/top_level.txt

@@ -0,0 +1,7 @@
+__init__
+const
+dat
+exceptions
+expressions
+func
+util

derivative_utils-0.1.0/src/exceptions.py

@@ -0,0 +1,2 @@
+class UnknownStdFunc(Exception):
+    pass

derivative_utils-0.1.0/src/expressions.py

@@ -0,0 +1,152 @@
+from decimal import Decimal
+import exceptions
+from func import *
+class MathExpression:
+  def __init__(self, value):
+    self.value = value
+  def __str__(self):
+    return str(self.value)
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val) 
+      return self.value.eval(val)
+class Number:
+  def __init__(self, value):
+    if type(value) != Decimal: value = Decimal(value)
+    self.value = value
+  def __str__(self):
+    return str(self.value)
+  def __sub__(self, n):
+    return Number(self.value-n)
+  def __add__(self, n):
+    return Number(self.value+n)
+  def eval(self, val=0):
+    return self.value
+class Product:
+  def __init__(self, a, b):
+    if type(a) == int or type(a) == float or type(a) == Decimal:
+      a = Number(a)
+    if type(b) == int or type(b) == float or type(b) == Decimal:
+      b = Number(b)
+      if (a == None): self.a = Number(1)
+      if (b == None): self.b = Number(1)
+    self.a = a
+    self.b = b
+  def __str__(self): return f"{self.a}*{self.b}"
+  def eval(self, val):
+    if type(val) != Number: val = Number(val)
+    return self.a.eval(val) * self.b.eval(val)
+class Quotient:
+  def __init__(self, a, b):
+    if type(a) == int or type(a) == float or type(a) == Decimal:
+      a = Number(a)
+      if type(b) == int or type(b) == float or type(b) == Decimal:
+        b = Number(b)
+      self.a = a
+      self.b = b
+  def __str__(self): return f"{self.a}/{self.b}"
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val)
+    return self.a.eval(val) / self.b.eval(val)
+class Sum:
+  def __init__(self, a, b):
+    if type(a) == int or type(a) == float or type(a) == Decimal:
+      a = Number(a)
+    if type(b) == int or type(b) == float or type(b) == Decimal:
+      b = Number(b)
+    self.a = a
+    self.b = b
+  def __str__(self): return f"({self.a}+{self.b})"
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val)
+    return self.a.eval(val) + self.b.eval(val)
+class Exponent:
+  def __init__(self, x, exp):
+    if type(x) == int or type(x) == float or type(x) == Decimal:
+      x = Number(x)
+    if type(exp) == int or type(exp) == float or type(exp) == Decimal:
+      exp = Number(exp)
+    self.x = x
+    self.exp = exp
+  def __str__(self): return f"({self.x})^({self.exp})"
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val)
+    return self.x.eval(val) ** self.exp.eval(val)
+class MainVariable:
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val)
+    return val.eval()
+  def __str__(self): return "x"
+class Polynomial(MathExpression):
+  def __init__(self, coefficients):
+    self.coeff = coefficients
+  def eval(self, x):
+    return sum([self.coeff[i]*x**(len(self.coeff-1-i)) for i in range(len(self.coeff))])
+  def __str__(self):
+    "+".join([f"{c}x^{len(self.coeff)-i-1}"] for i, c in enumerate(self.coeff))
+class Difference:
+  def __init__(self, a, b):
+    if type(a) == int or type(a) == float or type(a) == Decimal:
+      a = Number(a)
+    if type(b) == int or type(b) == float or type(b) == Decimal:
+      b = Number(b)
+    self.a = a
+    self.b = b
+  def __str__(self): return f"({self.a}-{self.b})"
+  def eval(self, val):
+    if type(val) != Number:
+      val = Number(val)
+    return self.a.eval(val) - self.b.eval(val)
+class StdFunction():
+  def __init__(self, ftype, val):
+    self.ftype = ftype
+    self.val = val
+    if ftype == "cos":
+      self.derivative = lambda argument: Product(-1, StdFunction("sin", argument, False)) 
+    elif ftype == "sin":
+      self.derivative = lambda argument: StdFunction("cos", argument, False)
+    elif ftype == "tan":
+      self.derivative = lambda argument: Quotient(1, Exponent(StdFunction("cos", argument, False), 2)) #replace with sec^2
+    elif ftype == "arccos":
+      self.derivative = lambda argument: Quotient(-1, Exponent(Difference(1,Exponent(argument,2)),Number(1/2)))
+    elif ftype == "arcsin":
+      self.derivative = lambda argument: Quotient(-1, Exponent(Difference(1, Exponent(argument,2)),Number(1/2)))
+    elif ftype == "arctan":
+      self.derivative = lambda argument: Quotient(1, Sum(1, Exponent(argument,2)))
+    elif ftype == "ln":
+      self.derivative = lambda argument: Exponent(argument, -1)
+    else:
+      raise(exceptions.UnknownStdFunc)
+  def __str__(self):
+    return f"{self.ftype}({self.val})"
+  def eval(self, x):
+    if self.ftype == "cos":
+      return cos(x)
+    elif self.ftype == "sin":
+      return sin(x)
+    elif self.ftype == "tan":
+      return tan(x)
+    elif self.ftype == "sec":
+      return sec(x)
+    elif self.ftype == "csc":
+      return csc(x)
+    elif self.ftype == "cot":
+      return cot(x)
+    elif self.ftype == "ln":
+      return ln(x)
+def simplify(exp):
+  if type(exp) == MathExpression: return simplify(exp.value)
+  elif type(exp) == Product:
+    if type(exp.a) == Number and exp.a.value == 1: return simplify(exp.b) #fix this
+    elif type(exp.b) == Number and exp.b.value == 1: return simplify(exp.a)
+    elif type(exp.a) == Number and exp.a.value == 0: return Number(0)
+    elif type(exp.b) == Number and exp.b.value == 0: return Number(0)
+  elif type(exp) == Quotient:
+    if exp.b == Number(1): return simplify(exp.a)
+    elif type(exp.b) == Quotient:
+      exp = Product(exp.a, Quotient(exp.b.b, exp.b.a))
+  return exp

derivative_utils-0.1.0/src/func.py

@@ -0,0 +1,47 @@
+from util import *
+from const import *
+from decimal import Decimal
+from expressions import *
+def cos(x, terms=100, places=12):
+    o = 0
+    x = x % (2*pi)
+    multiplier = 1
+    if x > pi:
+      x = x - pi
+      multiplier = -1
+    for i in range(terms):
+        c = [1, 0, -1, 0][i % 4]
+        o += Decimal(c*x**i)/Decimal(factorial(i))
+    return round(multiplier*o,places)
+def sin(x, terms=100, places=12):
+    o = 0
+    x = (x + pi/2) % (2*pi) - pi/2
+    for i in range(terms):
+        c = [0, 1, 0, -1][i % 4]
+        o += (c*x**i)/factorial(i)
+    return round(o,places)
+def tan(x, terms=100):
+    try: return sin(x, terms)/cos(x, terms)
+    except ZeroDivisionError: pass
+def sec(x, terms=100):
+    v = cos(x, terms)
+    if v == 0: return
+    else: return 1/v
+def csc(x, terms=100):
+    v = sin(x, terms)
+    if v == 0: return
+    else: return 1/v
+def cot(x, terms=100):
+    try: return cos(x, terms)/sin(x, terms)
+    except ZeroDivisionError: pass
+def exp(x, terms=100):
+  o = 0
+  if type(x) == Number: x = x.eval()
+  for i in range(terms):
+    o += x**i/factorial(i)
+  return o
+def ln(x, prec=0.000001):
+  guess = 0
+  while abs(exp(guess) - x) > prec:
+    guess -= (exp(guess) - x)/exp(guess)
+  return guess

derivative_utils-0.1.0/src/util.py

@@ -0,0 +1,14 @@
+from expressions import *
+from __init__ import differentiate
+def factorial(n):
+  o = 1
+  if n == 0:
+    return o
+  for i in [t+1 for t in range(n)]:
+    o*= i
+  return o
+def newtonMethod(function:MathExpression, prec=0.01, maxTries=1000):
+  guess = 0
+  tries = 0
+  while abs(function.eval(guess)) > prec and tries < maxTries:
+    guess -= function.eval(guess)/differentiate(function).eval(guess)