mathai 2.5.1__tar.gz → 2.5.3__tar.gz

{mathai-2.5.1 → mathai-2.5.3}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.5.1
+Version: 2.5.3
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: numpy
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{mathai-2.5.1 → mathai-2.5.3}/mathai/__init__.py

@@ -28,6 +28,7 @@ from .expand import expand
 
 from .ml import NeuralNetwork, diff_matrix_matrix
 from .mlscalar import NeuralNetworkScalar
+from .mldirect import NeuralNetworkDirect
 
 from .parser import parse, remove_extra_brackets
 
@@ -44,11 +45,7 @@ from .integrate import normalize as integration_basic
 
 from .diff import diff, diff2
 
-from .factor import factor as factor1
-from .factor import factor2, take_common
-from .factor import rationalize_sqrt as rationalize
-from .factor import merge_sqrt
-from .factor import factorconst as factor0
+from .factor import factor0, factor1, factor2
 
 from .fraction import fraction, fraction0
 

{mathai-2.5.1 → mathai-2.5.3}/mathai/decision.py

@@ -11,7 +11,7 @@ from .univariate_inequality import simple_wavycurvy, wavycurvy, prepare, absolut
 from .fraction import fraction
 from .expand import expand
 from .logic import logic0, set_sub, truth_gen, solve_logically
-from .factor import factor2, factor
+from .factor import factor2, factor1, factor0
 from .limit import limit1, limit5
 from .linear import linear_solve
 from .matrix import matrix_solve, matrix_formula

mathai-2.5.3/mathai/factor.py

@@ -0,0 +1,66 @@
+
+import math
+
+from .base import *  # tree_form, TreeNode, str_form, factor_generation, product, summation, partitions ...
+from .simplify import simplify
+from .expand import expand  # noqa: F401
+from .formula_compiler import formula_list_compiler
+
+# Kept so that `from .factor import *` in other modules keeps working.
+from .parser import parse  # noqa: F401
+from .simplify import convert_to_basic  # noqa: F401
+from .tool import poly  # noqa: F401
+from .fraction import fraction
+
+
+factor2 = formula_list_compiler("poly(x,a,b,c) a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) [] _ _ b^2-4*a*c _")
+factor1_s = """x^2-y^2 (x+y)*(x-y) [] _ _ _ _
+x^3-y^3 (x-y)*(x^2+x*y+y^2) [] _ _ _ _
+x^3+y^3 (x+y)*(x^2-x*y+y^2) [] _ _ _ _
+x*y+a*y+x+a (x+a)*(y+1) [[a,1]] _ _ _ _
+a*b+a*c a*(b+c) [[b,1]] _ _ _ _
+a*b*c+a*b*d a*b*(c+d) [] _ _ _ _
+a*x+b*x (a+b)*x [] _ _ _ _
+a*x+a*y a*(x+y) [] _ _ _ _
+a*c+a*d+b*c+b*d (a+b)*(c+d) [] _ _ _ _
+x^2+2*a*x+a^2 (x+a)^2 [] _ _ _ _
+x^2-2*a*x+a^2 (x-a)^2 [] _ _ _ _
+a*b*c+a*d a*(b*c+d) [] _ _ _ _"""
+factor1 = formula_list_compiler(factor1_s)
+
+def _coeff(term):
+    """Integer coefficient of a term (1 if none)."""
+    for item in factor_generation(term):
+        if item.name.startswith("d_"):
+            try:
+                return int(item.name[2:])
+            except ValueError:
+                return 1
+    return 1
+
+
+def _hcf(numbers):
+    """gcd of the coefficients; negative only if every coefficient is negative."""
+    g = 0
+    for x in numbers:
+        g = math.gcd(g, x)
+    if g == 0:
+        return 1
+    if numbers and all(x < 0 for x in numbers):
+        return -g
+    return g
+
+
+def _factorconst(eq):
+    if not eq.children:
+        return eq
+    if eq.name == "f_add":
+        n = _hcf([_coeff(child) for child in eq.children])
+        if n != 1:
+            const = tree_form("d_" + str(n))
+            return const * TreeNode(eq.name, [child / const for child in eq.children])
+    return TreeNode(eq.name, [_factorconst(child) for child in eq.children])
+
+
+def factor0(eq):
+    return simplify(_factorconst(eq))

{mathai-2.5.1 → mathai-2.5.3}/mathai/integrate.py

@@ -1,6 +1,4 @@
-from .factor import factor2
-from .factor import factorconst as factor0
-from .factor import factor as factor1
+from .factor import factor2, factor1, factor0
 from .parser import parse
 import itertools
 from .diff import diff
@@ -289,14 +287,14 @@ def byparts(eq):
             return TreeNode("f_try", output)
         eq = eq2
     return TreeNode(eq.name, [byparts(child) for child in eq.children])
-
 integrate_fraction_s = """integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(a)*log(abs(sqrt(a)*x+b/(2*sqrt(a))+sqrt((sqrt(a)*x+b/(2*sqrt(a)))^2+(4*a*c-b^2)/(4*a)))) [] x [a,b,c] [a,4*a*c-b^2] _ [[a,0],[b^2-4*a*c,0]]
 integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(a)*log(abs(sqrt(a)*x+b/(2*sqrt(a))+sqrt((sqrt(a)*x+b/(2*sqrt(a)))^2-(b^2-4*a*c)/(4*a)))) [] x [a,b,c] [a,b^2-4*a*c] _ [[a,0],[4*a*c-b^2,0]]
 integrate(1/sqrt(poly(x,a,b,c)),x) 1/sqrt(-a)*arcsin((sqrt(-a)*x-b/(2*sqrt(-a)))/sqrt((4*a*c-b^2)/(4*a))) [] x [a,b,c] [4*a*c-b^2] a [[a,0],[b^2-4*a*c,0]]
 integrate(1/poly(x,a,b,c),x) 1/(sqrt(a)*sqrt((4*a*c-b^2)/(4*a)))*arctan((sqrt(a)*x+b/(2*sqrt(a)))/sqrt((4*a*c-b^2)/(4*a))) [] x [a,b,c] [a,4*a*c-b^2] _ [[a,0],[b^2-4*a*c,0]]
-integrate(1/poly(x,a,b,c),x) -1/(sqrt(-a)*sqrt((b^2-4*a*c)/(-4*a)))*arctan((sqrt(-a)*x-b/(2*sqrt(-a)))/sqrt((b^2-4*a*c)/(-4*a))) [] x [a,b,c] _ [a,b^2-4*a*c] [[a,0],[4*a*c-b^2,0]]
+integrate(1/poly(x,a,b,c),x) -1/(sqrt(-a)*sqrt((4*a*c-b^2)/(-4*a)))*arctan((sqrt(-a)*x-b/(2*sqrt(-a)))/sqrt((4*a*c-b^2)/(-4*a))) [] x [a,b,c] [4*a*c-b^2] a [[a,0],[b^2-4*a*c,0]]
 integrate(poly(x,p,q)/sqrt(poly(x,a,b,c)),x) (p/a)*sqrt(a*x^2+b*x+c)+(q-p*b/(2*a))*integrate(1/sqrt(a*x^2+b*x+c),x) [] x [p,q,a,b,c] _ _ _ [[a,0]]
 integrate(poly(x,p,q)/poly(x,a,b,c),x) (p/(2*a))*log(abs(a*x^2+b*x+c))+(q-p*b/(2*a))*integrate(1/(a*x^2+b*x+c),x) [] x [p,q,a,b,c] _ _ _ [[a,0]]"""
+
 integrate_fraction = formula_list_compiler(integrate_fraction_s)
 
 def_integrate_formula_s = """integrate(abs(poly(x,a,b)),x,m,n) ((a*n+b)*abs(a*n+b)-(a*m+b)*abs(a*m+b))/(2*a) [] x [a,b] _ _

{mathai-2.5.1 → mathai-2.5.3}/mathai/linear.py

@@ -6,7 +6,7 @@ from .simplify import simplify
 from .fraction import fraction
 from .expand import expand
 from .base import *
-from .factor import factorconst
+
 from .tool import poly
 
 def ss(eq):

{mathai-2.5.1 → mathai-2.5.3}/mathai/logic.py

@@ -4,7 +4,7 @@ from .base import *
 from .fraction import fraction
 from .simplify import simplify
 from .expand import expand
-from .factor import factorconst
+
 def set_sub(eq):
   if eq.name == "f_sub":
     return eq.children[0] & eq.children[1].fx("not")

{mathai-2.5.1 → mathai-2.5.3}/mathai/ml.py

@@ -675,7 +675,7 @@ class NeuralNetwork:
                 A_list = A_list + flatten_list(item)
             exec(s, env2)
             return env2["fx"](A_list,flatten_list(given_x))
-    def train(self, train_x, train_y, learning_rate, epoch, batch_size=1):
+    def train(self, train_x, train_y, learning_rate=12, epoch=10000, batch_size=1):
         global hadamard, zeros, transpose, matadd, sigmoid, identity, power, vec, diag, flatten,\
                matmul, reshape, kronecker, commutation, broadcast, im2col, conv, col2im
         print("gradients calculated")