mathai 2.2.4__tar.gz → 2.2.5__tar.gz

{mathai-2.2.4 → mathai-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.4
+Version: 2.2.5
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
@@ -467,7 +467,7 @@ solve_graphics_string("15 25 0 None None None None None None 30*pi/180 0 50 None
 print()
 solve_graphics_string("0 -25 0 None None None None None None None 0 55 None 75") # 11.17
 print()
-solve_graphics_string("25 50 0 -30 None None None None None None 0 50 None 80") # 11.19
+solve_graphics_string("25 50 0 -30 None None None None None None 0 None None 80") # 11.19
 ```
 
 #### Output
@@ -477,14 +477,14 @@ Ay : 20
 Az : 0
 Bx : 30
 By : 20+(60*sin(((2*pi)/9)))
-Bz : 60*abs(cos(((2*pi)/9)))
+Bz : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 Bx-Ax : 0
 By-Ay : 60*sin(((2*pi)/9))
-Bz-Az : 60*abs(cos(((2*pi)/9)))
+Bz-Az : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 inclination_with_VP : 0
 inclination_with_HP : (2*pi)/9
 front_view_length : 60
-top_view_length : 60*abs(cos(((2*pi)/9)))
+top_view_length : sqrt((3600-(3600*(sin(((2*pi)/9))^2))))
 line_length : 60
 
 Ax : 20
@@ -520,16 +520,16 @@ line_length : 100/(3^-(-1/2))
 Ax : 0
 Ay : -25
 Az : 0
-Bx : 75*sin(arccos((11/15)))
+Bx : 5*sqrt(104)
 By : -25
 Bz : 55
-Bx-Ax : 75*sin(arccos((11/15)))
+Bx-Ax : 5*sqrt(104)
 By-Ay : 0
 Bz-Az : 55
-inclination_with_VP : arccos((11/15))
+inclination_with_VP : arcsin((sqrt(104)/15))
 inclination_with_HP : 0
 front_view_length : 55
-top_view_length : sqrt((3025+(5625*(sin(arccos((11/15)))^2))))
+top_view_length : 75
 line_length : 75
 
 Ax : 25
@@ -537,14 +537,14 @@ Ay : 50
 Az : 0
 Bx : -30
 By : 50
-Bz : 80*abs(cos(arcsin((-11/16))))
+Bz : 5*sqrt(135)
 Bx-Ax : -55
 By-Ay : 0
-Bz-Az : 80*abs(cos(arcsin((-11/16))))
+Bz-Az : 5*sqrt(135)
 inclination_with_VP : arcsin((-11/16))
 inclination_with_HP : 0
-front_view_length : 50
-top_view_length : sqrt((3025+(6400*(cos(arcsin((-11/16)))^2))))
+front_view_length : sqrt(3375)
+top_view_length : 80
 line_length : 80
 ```
 

{mathai-2.2.4 → mathai-2.2.5}/README.md

@@ -451,7 +451,7 @@ solve_graphics_string("15 25 0 None None None None None None 30*pi/180 0 50 None
 print()
 solve_graphics_string("0 -25 0 None None None None None None None 0 55 None 75") # 11.17
 print()
-solve_graphics_string("25 50 0 -30 None None None None None None 0 50 None 80") # 11.19
+solve_graphics_string("25 50 0 -30 None None None None None None 0 None None 80") # 11.19
 ```
 
 #### Output
@@ -461,14 +461,14 @@ Ay : 20
 Az : 0
 Bx : 30
 By : 20+(60*sin(((2*pi)/9)))
-Bz : 60*abs(cos(((2*pi)/9)))
+Bz : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 Bx-Ax : 0
 By-Ay : 60*sin(((2*pi)/9))
-Bz-Az : 60*abs(cos(((2*pi)/9)))
+Bz-Az : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 inclination_with_VP : 0
 inclination_with_HP : (2*pi)/9
 front_view_length : 60
-top_view_length : 60*abs(cos(((2*pi)/9)))
+top_view_length : sqrt((3600-(3600*(sin(((2*pi)/9))^2))))
 line_length : 60
 
 Ax : 20
@@ -504,16 +504,16 @@ line_length : 100/(3^-(-1/2))
 Ax : 0
 Ay : -25
 Az : 0
-Bx : 75*sin(arccos((11/15)))
+Bx : 5*sqrt(104)
 By : -25
 Bz : 55
-Bx-Ax : 75*sin(arccos((11/15)))
+Bx-Ax : 5*sqrt(104)
 By-Ay : 0
 Bz-Az : 55
-inclination_with_VP : arccos((11/15))
+inclination_with_VP : arcsin((sqrt(104)/15))
 inclination_with_HP : 0
 front_view_length : 55
-top_view_length : sqrt((3025+(5625*(sin(arccos((11/15)))^2))))
+top_view_length : 75
 line_length : 75
 
 Ax : 25
@@ -521,14 +521,14 @@ Ay : 50
 Az : 0
 Bx : -30
 By : 50
-Bz : 80*abs(cos(arcsin((-11/16))))
+Bz : 5*sqrt(135)
 Bx-Ax : -55
 By-Ay : 0
-Bz-Az : 80*abs(cos(arcsin((-11/16))))
+Bz-Az : 5*sqrt(135)
 inclination_with_VP : arcsin((-11/16))
 inclination_with_HP : 0
-front_view_length : 50
-top_view_length : sqrt((3025+(6400*(cos(arcsin((-11/16)))^2))))
+front_view_length : sqrt(3375)
+top_view_length : 80
 line_length : 80
 ```
 

{mathai-2.2.4 → mathai-2.2.5}/mathai/graphics.py

@@ -4,10 +4,8 @@ from .simplify import simplify
 from .trig import trig0
 import itertools
 from .inverse import inverse
-from .formula_data import compile_formula
 from .expand import expand
 from .parser import parse
-
 def solve_graphics(Ax, Ay, Az, Bx, By, Bz, BAx, BAy, BAz, phi, theta, fvl, tvl, length):
     eq1 = TreeNode("f_eq", [TreeNode("v_6"), TreeNode("v_3") - TreeNode("v_0")])
     eq2 = TreeNode("f_eq", [TreeNode("v_7"), TreeNode("v_4") - TreeNode("v_1")])
@@ -17,52 +15,36 @@ def solve_graphics(Ax, Ay, Az, Bx, By, Bz, BAx, BAy, BAz, phi, theta, fvl, tvl,
     eq6 = TreeNode("f_eq", [TreeNode("v_8"), (TreeNode("d_1") - TreeNode("v_9").fx("sin")**2 - TreeNode("v_10").fx("sin")**2).fx("sqrt") * TreeNode("v_13")])
     eq7 = TreeNode("f_eq", [TreeNode("v_12")**2, (TreeNode("v_3") - TreeNode("v_0"))**2 + (TreeNode("v_5") - TreeNode("v_2"))**2])
     eq8 = TreeNode("f_eq", [TreeNode("v_11")**2, (TreeNode("v_4") - TreeNode("v_1"))**2 + (TreeNode("v_5") - TreeNode("v_2"))**2])
-    
     q = operation("f_and", [eq1, eq2, eq3, eq4, eq5, eq6, eq7, eq8])
     lst = [Ax, Ay, Az, Bx, By, Bz, BAx, BAy, BAz, phi, theta, fvl, tvl, length]
     name = "Ax Ay Az Bx By Bz Bx-Ax By-Ay Bz-Az inclination_with_VP inclination_with_HP front_view_length top_view_length line_length".split(" ")
-    
     solution = {}
     for index, item in enumerate(lst):
         if item is not None:
             solution[f"v_{index}"] = item
-
-    fx = compile_formula("sin(x)^2 1-cos(x)^2 _ _ _ _ _ _ _ 2")
     q = simplify(q)
-    
     done = True
     while done:
         done = False
         for i in range(len(q.children)):
             item = q.children[i]
-            # Replace known variables
             for key, item2 in solution.items():
                 item = replace(item, TreeNode(key), item2)
-            
-            # Apply trig identities during simplification
-            item = fraction(expand(trig0(fx(simplify(item)))))
+            item = fraction(expand(trig0(simplify(item))))
             q.children[i] = item
-            
-            # Solvable equation check
             vars_in_item = vlist(item)
             if len(vars_in_item) == 1:
                 target_var = vars_in_item[0]
-                # Pass the full equation node (or LHS - RHS) so inverse() has both sides
                 solution[target_var] = inverse(item.children[0], target_var)
                 done = True
                 break
-                
-    # Map back to readable parameter names safely
     final_solution = {}
     for i, param_name in enumerate(name):
         var_key = f"v_{i}"
         if var_key in solution:
             final_solution[param_name] = simplify(expand(solution[var_key]))
-            
     return final_solution
-
 def solve_graphics_string(s):
-    # Use s.split() to handle arbitrary whitespace cleanly
     s_parsed = [None if item == "None" else parse(item) for item in s.split()]
     for key, item in solve_graphics(*s_parsed).items():
         print(f"{key} : {item}")

{mathai-2.2.4 → mathai-2.2.5}/mathai/inverse.py

@@ -1,23 +1,25 @@
 from .base import *
 from .simplify import simplify
 from .expand import expand
-def inverse(rhs,term, sign=None):
+import copy
+def inverse(rhs, term, sign=None):
     term = tree_form(term)
     lhs = tree_form("d_0")
+    rhs = copy.deepcopy(rhs)
     count = 15
-    while not rhs==term:
+    while not rhs == term:
         if rhs.name == "f_add":
-            if all(term in factor_generation(child) for child in rhs.children):
-                newrhs = simplify(expand(rhs*term**-1))
+            if rhs.children and all(term in factor_generation(child) for child in rhs.children):
+                newrhs = simplify(expand(rhs * term**-1))
                 if not contain(newrhs, term):
                     rhs = term * newrhs
             else:
-                for i in range(len(rhs.children)-1,-1,-1):
+                for i in range(len(rhs.children) - 1, -1, -1):
                     if not contain(rhs.children[i], term):
                         lhs = lhs - rhs.children[i]
                         rhs.children.pop(i)
         elif rhs.name == "f_mul":
-            for i in range(len(rhs.children)-1,-1,-1):
+            for i in range(len(rhs.children) - 1, -1, -1):
                 if not contain(rhs.children[i], term):
                     lhs = lhs * rhs.children[i]**-1
                     if sign is not None:
@@ -26,11 +28,17 @@ def inverse(rhs,term, sign=None):
                         if compute(rhs.children[i]**-1) < 0:
                             sign = not sign
                     rhs.children.pop(i)
-        elif rhs.name == "f_pow" and contain(rhs.children[0], term):
-            lhs = lhs ** (tree_form("d_1")/rhs.children[1])
+        elif rhs.name == "f_pow" and contain(rhs.children[0], term) and not contain(rhs.children[1], term):
+            lhs = lhs ** (tree_form("d_1") / rhs.children[1])
+            if sign is not None:
+                if compute(rhs.children[1]) < 0:
+                    sign = not sign
             rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_pow" and rhs.children[0].name == "s_e" and contain(rhs.children[1], term):
+            lhs = lhs.fx("log")
+            rhs = copy.deepcopy(rhs.children[1])
         elif rhs.name == "f_pow" and contain(rhs.children[1], term) and not contain(rhs.children[0], term):
-            lhs = lhs.fx("log")/rhs.children[0].fx("log")
+            lhs = lhs.fx("log") / rhs.children[0].fx("log")
             rhs = copy.deepcopy(rhs.children[1])
         elif rhs.name == "f_sin" and contain(rhs.children[0], term):
             lhs = lhs.fx("arcsin")
@@ -40,27 +48,30 @@ def inverse(rhs,term, sign=None):
             rhs = copy.deepcopy(rhs.children[0])
         elif rhs.name == "f_arccos" and contain(rhs.children[0], term):
             lhs = lhs.fx("cos")
+            if sign is not None:
+                sign = not sign
             rhs = copy.deepcopy(rhs.children[0])
         elif rhs.name == "f_cos" and contain(rhs.children[0], term):
             lhs = lhs.fx("arccos")
+            if sign is not None:
+                sign = not sign
             rhs = copy.deepcopy(rhs.children[0])
         elif rhs.name == "f_log" and contain(rhs.children[0], term):
             lhs = tree_form("s_e")**lhs
             rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_pow" and rhs.children[0].name == "s_e" and contain(rhs.children[1], term):
-            lhs = lhs.fx("log")
-            rhs = copy.deepcopy(rhs.children[1].fx("log"))
         elif rhs.name == "f_tan" and contain(rhs.children[0], term):
             lhs = lhs.fx("arctan")
             rhs = copy.deepcopy(rhs.children[0])
         elif rhs.name == "f_arctan" and contain(rhs.children[0], term):
             lhs = lhs.fx("tan")
             rhs = copy.deepcopy(rhs.children[0])
-        if len(rhs.children) == 1:
+        if rhs.name in ["f_add", "f_mul"] and len(rhs.children) == 1:
             rhs = rhs.children[0]
         count -= 1
         if count == 0:
             return None
+    if contain(lhs, term):
+        return None
     if sign is None:
         return simplify(lhs)
     return simplify(lhs), sign

{mathai-2.2.4 → mathai-2.2.5}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.4
+Version: 2.2.5
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
@@ -467,7 +467,7 @@ solve_graphics_string("15 25 0 None None None None None None 30*pi/180 0 50 None
 print()
 solve_graphics_string("0 -25 0 None None None None None None None 0 55 None 75") # 11.17
 print()
-solve_graphics_string("25 50 0 -30 None None None None None None 0 50 None 80") # 11.19
+solve_graphics_string("25 50 0 -30 None None None None None None 0 None None 80") # 11.19
 ```
 
 #### Output
@@ -477,14 +477,14 @@ Ay : 20
 Az : 0
 Bx : 30
 By : 20+(60*sin(((2*pi)/9)))
-Bz : 60*abs(cos(((2*pi)/9)))
+Bz : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 Bx-Ax : 0
 By-Ay : 60*sin(((2*pi)/9))
-Bz-Az : 60*abs(cos(((2*pi)/9)))
+Bz-Az : 60*sqrt((1-(sin(((2*pi)/9))^2)))
 inclination_with_VP : 0
 inclination_with_HP : (2*pi)/9
 front_view_length : 60
-top_view_length : 60*abs(cos(((2*pi)/9)))
+top_view_length : sqrt((3600-(3600*(sin(((2*pi)/9))^2))))
 line_length : 60
 
 Ax : 20
@@ -520,16 +520,16 @@ line_length : 100/(3^-(-1/2))
 Ax : 0
 Ay : -25
 Az : 0
-Bx : 75*sin(arccos((11/15)))
+Bx : 5*sqrt(104)
 By : -25
 Bz : 55
-Bx-Ax : 75*sin(arccos((11/15)))
+Bx-Ax : 5*sqrt(104)
 By-Ay : 0
 Bz-Az : 55
-inclination_with_VP : arccos((11/15))
+inclination_with_VP : arcsin((sqrt(104)/15))
 inclination_with_HP : 0
 front_view_length : 55
-top_view_length : sqrt((3025+(5625*(sin(arccos((11/15)))^2))))
+top_view_length : 75
 line_length : 75
 
 Ax : 25
@@ -537,14 +537,14 @@ Ay : 50
 Az : 0
 Bx : -30
 By : 50
-Bz : 80*abs(cos(arcsin((-11/16))))
+Bz : 5*sqrt(135)
 Bx-Ax : -55
 By-Ay : 0
-Bz-Az : 80*abs(cos(arcsin((-11/16))))
+Bz-Az : 5*sqrt(135)
 inclination_with_VP : arcsin((-11/16))
 inclination_with_HP : 0
-front_view_length : 50
-top_view_length : sqrt((3025+(6400*(cos(arcsin((-11/16)))^2))))
+front_view_length : sqrt(3375)
+top_view_length : 80
 line_length : 80
 ```
 

{mathai-2.2.4 → mathai-2.2.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 from pathlib import Path
 setup(
     name="mathai",
-    version="2.2.4",
+    version="2.2.5",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",