mathai 2.2.4__tar.gz → 2.2.6__tar.gz

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.4
+Version: 2.2.6
 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: more_itertools
-Requires-Dist: schemdraw
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
@@ -438,7 +437,6 @@ wire_4 = Edge((4, 9))
 edge_list = [wire_1, wire_2, wire_3, wire_4,ohm_5, ohm_6, ohm_7, ohm_8, ohm_8_2, ohm_10, ohm_11, ohm_20]
 graph = CircuitGraph(10, edge_list, {})
 print(compute(find_resistance(graph, 0, 9)))
-draw_circuit(graph, start=0, end=9, scale=3.0, grid_size=30)
 ```
 
 #### Output
@@ -450,7 +448,29 @@ done
 8.66474543707973
 ```
 
-#### Example Demonstration 11 (engineering graphics)
+#### Example Demonstration 11 (resistors in parallel)
+```python
+from mathai import *
+load_formula_from_file()
+wire_1 = Edge((1, 3))
+wire_2 = Edge((2, 3))
+ohm_r1 = Edge((0, 1), "resistor", parse("x"))
+ohm_r2 = Edge((0, 2), "resistor", parse("y"))
+edge_list = [wire_1, ohm_r1, ohm_r2, wire_2]
+graph = CircuitGraph(4, edge_list, {})
+print(fraction(find_resistance(graph, 0, 3)))
+```
+
+#### Output
+
+```
+loading formulas from file...
+done
+
+(x*y)/(x+y)
+```
+
+#### Example Demonstration 12 (engineering graphics)
 ```python
 from mathai import *
 # (z,y) is dash, a'b' is front view
@@ -467,7 +487,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 +497,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 +540,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 +557,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.6}/README.md

@@ -422,7 +422,6 @@ wire_4 = Edge((4, 9))
 edge_list = [wire_1, wire_2, wire_3, wire_4,ohm_5, ohm_6, ohm_7, ohm_8, ohm_8_2, ohm_10, ohm_11, ohm_20]
 graph = CircuitGraph(10, edge_list, {})
 print(compute(find_resistance(graph, 0, 9)))
-draw_circuit(graph, start=0, end=9, scale=3.0, grid_size=30)
 ```
 
 #### Output
@@ -434,7 +433,29 @@ done
 8.66474543707973
 ```
 
-#### Example Demonstration 11 (engineering graphics)
+#### Example Demonstration 11 (resistors in parallel)
+```python
+from mathai import *
+load_formula_from_file()
+wire_1 = Edge((1, 3))
+wire_2 = Edge((2, 3))
+ohm_r1 = Edge((0, 1), "resistor", parse("x"))
+ohm_r2 = Edge((0, 2), "resistor", parse("y"))
+edge_list = [wire_1, ohm_r1, ohm_r2, wire_2]
+graph = CircuitGraph(4, edge_list, {})
+print(fraction(find_resistance(graph, 0, 3)))
+```
+
+#### Output
+
+```
+loading formulas from file...
+done
+
+(x*y)/(x+y)
+```
+
+#### Example Demonstration 12 (engineering graphics)
 ```python
 from mathai import *
 # (z,y) is dash, a'b' is front view
@@ -451,7 +472,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 +482,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 +525,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 +542,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.6}/mathai/__init__.py

@@ -7,7 +7,7 @@ from .qm import hydrogen_gse, helium_gse, power_rule
 
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 
-from .electronic import Edge, CircuitGraph, find_resistance, draw_circuit
+from .electronic import Edge, CircuitGraph, find_resistance
 
 from .linear import linear_solve
 

{mathai-2.2.4 → mathai-2.2.6}/mathai/electronic.py

@@ -1,4 +1,3 @@
-import random
 import copy
 from .base import *
 from .simplify import simplify
@@ -12,6 +11,7 @@ class Edge:
         self.value = value
         self.edge = tuple(edge) if edge else None
         self.current = None
+        self.voltage = None
 class CircuitGraph:
     def __init__(self, node_count=0, edge_list=None, connection=None):
         self.node_count = node_count
@@ -26,7 +26,7 @@ class CircuitGraph:
             if edge.edge:
                 self.node_count = max(self.node_count, max(edge.edge) + 1)
         self.connection = copy.deepcopy(connection) if connection else {}
-        self.variable_list = [TreeNode(f"v_{i}") for i in range(26)]
+        self.variable_list = [TreeNode(f"v_{i}") for i in range(6,26)]
         self.complete_connection()
     def complete_connection(self):
         for i in range(self.node_count):
@@ -174,19 +174,21 @@ class CircuitGraph:
         missing = [i for i, edge in enumerate(self.edge_list) if edge.current is None]
         if missing:
             raise ValueError(f"Could not determine currents: {missing}")
-def find_resistance(circuit, start, end):
+def find_resistance(circuit, start=None, end=None, compute_current_only=False):
     circuit = copy.deepcopy(circuit)
-    if start == end:
+    if start == end and start is not None and end is not None:
         return TreeNode("d_0")
-    new_node = circuit.node_count
-    circuit.node_count += 1
-    cell = Edge((end, new_node), "cell", TreeNode("d_1"))
-    wire = Edge((new_node, start), "wire")
-    circuit.edge_list.append(cell)
-    cell_idx = len(circuit.edge_list) - 1
-    circuit.edge_list.append(wire)
+    cell_idx = None
+    if not compute_current_only:
+        new_node = circuit.node_count
+        circuit.node_count += 1
+        cell = Edge((end, new_node), "cell", TreeNode("d_1"))
+        wire = Edge((new_node, start), "wire")
+        circuit.edge_list.append(cell)
+        cell_idx = len(circuit.edge_list) - 1
+        circuit.edge_list.append(wire)
     circuit.complete_connection()
-    circuit.assign_currents(cell_idx)
+    circuit.assign_currents()
     cycles = circuit.all_simple_cycle()
     equations = []
     for cycle in cycles:
@@ -200,210 +202,29 @@ def find_resistance(circuit, start, end):
         [TreeNode("f_eq", [equation, TreeNode("d_0")]) for equation in equations]
     )
     equations = simplify(fraction(simplify(equations)))
-    equations = linear_solve(equations)
+    const_list = []
+    for item in circuit.edge_list:
+        if item.edge_type == "resistor":
+            const_list += [TreeNode(item) for item in vlist(item.value)]
+    equations = linear_solve(equations, const_list)
     solutions = {}
     equation_list = equations.children if equations.name == "f_and" else [equations]
     for equation in equation_list:
-        variables = vlist(equation)
+        variables = list(set(vlist(equation))-set([item.name for item in const_list]))
         if len(variables) != 1:
             continue
         variable = variables[0]
         solutions[variable] = inverse(equation.children[0], variable)
+    for index, item in enumerate(circuit.edge_list):
+        for v in vlist(circuit.edge_list[index].current):
+            if TreeNode(v) in const_list:
+                continue
+            circuit.edge_list[index].current = simplify(replace(circuit.edge_list[index].current, TreeNode(v), solutions[v]))
+    if compute_current_only:
+        return circuit
     current = circuit.edge_list[cell_idx].current
     for variable, value in solutions.items():
         if variable in vlist(current):
             current = replace(current, tree_form(variable), value)
     current = simplify(TreeNode("d_1")/current)
     return current
-import random
-import schemdraw
-import schemdraw.elements as elm
-
-
-def on_segment(p, a, b):
-    """Returns True if point p lies exactly on the line segment a-b."""
-    # Collinearity check (cross product == 0)
-    cross = (p[0] - a[0]) * (b[1] - a[1]) - (p[1] - a[1]) * (b[0] - a[0])
-    if abs(cross) > 1e-6:
-        return False
-    # Bounding box check
-    if min(a[0], b[0]) <= p[0] <= max(a[0], b[0]) and \
-       min(a[1], b[1]) <= p[1] <= max(a[1], b[1]):
-        return True
-    return False
-
-
-def segments_conflict_exact(a, b, c, d):
-    """
-    Checks if segment ab conflicts with cd (intersects or overlaps), 
-    ignoring shared endpoints unless they perfectly overlap.
-    """
-    def ccw(p, q, r):
-        return (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0])
-
-    c1, c2 = ccw(a, b, c), ccw(a, b, d)
-    c3, c4 = ccw(c, d, a), ccw(c, d, b)
-
-    # 1. True geometric intersection (lines cross)
-    if ((c1 > 0 and c2 < 0) or (c1 < 0 and c2 > 0)) and \
-       ((c3 > 0 and c4 < 0) or (c3 < 0 and c4 > 0)):
-        return True
-
-    # 2. Collinear overlap (one point lies strictly inside the other segment)
-    if on_segment(c, a, b) and c != a and c != b: return True
-    if on_segment(d, a, b) and d != a and d != b: return True
-    if on_segment(a, c, d) and a != c and a != d: return True
-    if on_segment(b, c, d) and b != c and b != d: return True
-
-    # 3. Identical overlapping segments
-    if (a == c and b == d) or (a == d and b == c):
-        return True
-
-    return False
-
-
-def get_all_candidate_routes(p1, p2):
-    """Generates all valid orthogonal straight line and 1-bend L-routes."""
-    x1, y1 = p1
-    x2, y2 = p2
-
-    # Collinear (Straight line along single axis)
-    if x1 == x2 or y1 == y2:
-        return [[p1, p2]]
-
-    # Standard L-shapes (Horizontal-first or Vertical-first)
-    return [
-        [p1, (x1, y2), p2],
-        [p1, (x2, y1), p2]
-    ]
-
-
-def route_to_segments(route):
-    return [(route[i], route[i + 1]) for i in range(len(route) - 1)]
-
-
-def check_route_conflict(route, placed_routes, node_positions, u, v):
-    """Validates that a new route does not cross placed routes or run over unrelated nodes."""
-    segs = route_to_segments(route)
-    
-    # 1. Check against already placed routes
-    for placed_route in placed_routes:
-        placed_segs = route_to_segments(placed_route)
-        for a, b in segs:
-            for c, d in placed_segs:
-                if segments_conflict_exact(a, b, c, d):
-                    return True
-                    
-    # 2. Check against nodes (prevent line from running through an unrelated node)
-    for node, pos in node_positions.items():
-        if node == u or node == v:
-            continue  # Permitted to touch its own endpoints
-        for a, b in segs:
-            if on_segment(pos, a, b):
-                return True
-                
-    return False
-
-
-def solve_routing(edges, node_positions):
-    """DFS Backtracking to find a 100% collision-free route mapping for a given node layout."""
-    placed_routes = []
-    
-    def backtrack(edge_idx):
-        if edge_idx == len(edges):
-            return True
-        
-        edge = edges[edge_idx]
-        u, v = edge.edge
-        p1, p2 = node_positions[u], node_positions[v]
-        
-        candidate_routes = get_all_candidate_routes(p1, p2)
-        random.shuffle(candidate_routes) 
-        
-        for route in candidate_routes:
-            if not check_route_conflict(route, placed_routes, node_positions, u, v):
-                placed_routes.append(route)
-                if backtrack(edge_idx + 1):
-                    return True
-                placed_routes.pop()
-        return False
-        
-    if backtrack(0):
-        return placed_routes
-    return None
-
-
-def draw_circuit(graph, start=None, end=None, scale=3.0, grid_size=12, max_attempts=10000):
-    """
-    Renders a circuit using randomized grid placement and exact geometric backtracking.
-    Guarantees strict L/straight paths without line intersections or bugs.
-    """
-    edges = graph.edge_list
-    all_nodes = set()
-    for edge in edges:
-        all_nodes.add(edge.edge[0])
-        all_nodes.add(edge.edge[1])
-        
-    nodes_list = sorted(list(all_nodes))
-
-    best_positions = None
-    best_routes = None
-
-    # Search for a node configuration that allows a perfect non-intersecting layout
-    for _ in range(max_attempts):
-        # Generate random available grid locations
-        available_cells = [
-            (col * scale, -row * scale)
-            for row in range(grid_size)
-            for col in range(grid_size)
-        ]
-        random.shuffle(available_cells)
-
-        current_positions = {node: available_cells[i] for i, node in enumerate(nodes_list)}
-
-        # Attempt to perfectly route all edges
-        routes = solve_routing(edges, current_positions)
-        
-        if routes is not None:
-            best_positions = current_positions
-            best_routes = routes
-            break  # Perfect layout found!
-
-    if best_routes is None:
-        raise RuntimeError("Failed to find a non-intersecting layout. Try increasing grid_size or max_attempts.")
-
-    # Render Circuit Diagram with Schemdraw
-    d = schemdraw.Drawing()
-
-    for idx, edge in enumerate(edges):
-        route = best_routes[idx]
-        segs = route_to_segments(route)
-        resistor = getattr(edge, "edge_type", "") == "resistor"
-        value = getattr(edge, "value", "")
-
-        for i, (p1, p2) in enumerate(segs):
-            # Place resistor component on the last segment of the route
-            if resistor and i == len(segs) - 1:
-                lbl = f"{value} Ω" if value else ""
-                d.add(
-                    elm.Resistor()
-                    .at(p1)
-                    .to(p2)
-                    .label(lbl)
-                )
-            else:
-                d.add(elm.Line().at(p1).to(p2))
-
-    # Draw Nodes
-    for node, pos in best_positions.items():
-        d.add(elm.Dot().at(pos))
-
-    # Add Terminal Labels
-    if start is not None and start in best_positions:
-        d.add(elm.Label().at(best_positions[start]).label("Start", loc="left"))
-
-    if end is not None and end in best_positions:
-        d.add(elm.Label().at(best_positions[end]).label("End", loc="right"))
-
-    d.draw()
-    return d

{mathai-2.2.4 → mathai-2.2.6}/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.6}/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.6}/mathai/linear.py

@@ -1,5 +1,6 @@
 from .inverse import inverse
 import itertools
+import copy
 from .diff import diff
 from .simplify import simplify
 from .fraction import fraction
@@ -7,8 +8,10 @@ from .expand import expand
 from .base import *
 from .factor import factorconst
 from .tool import poly
+
 def ss(eq):
     return dowhile(eq, lambda x: fraction(simplify(x)))
+
 def rref(matrix, fxconst):
     rows, cols = len(matrix), len(matrix[0])
     lead = 0
@@ -32,25 +35,28 @@ def rref(matrix, fxconst):
                 matrix[i] = [ss(m - lv * n) for m, n in zip(matrix[i], matrix[r])]
         lead += 1
     return matrix
+
 def linear(eqlist, fxconst):
     orig = [item.copy_tree() for item in eqlist]
-    v2 = []
     vl = []
+    
     def varlist(eq, fxconst):
         nonlocal vl
-        nonlocal v2
-        if eq.name[:2] == "v_" and fxconst(eq):
-            vl.append(eq.name)
         if eq.name[:2] == "v_" and not fxconst(eq):
-            v2.append(eq.name)
+            vl.append(eq.name)
         for child in eq.children:
             varlist(child, fxconst)
+            
     for eq in eqlist:
         varlist(eq, fxconst)
-    vl = v2
-    vl = list(set(vl))
+        
+    vl = sorted(list(set(vl)))
+    
     if len(vl) > len(eqlist):
+        if len(eqlist) == 1:
+            return TreeNode("f_eq", [eqlist[0], tree_form("d_0")])
         return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
+        
     m = []
     for eq in eqlist:
         s = copy.deepcopy(eq)
@@ -60,36 +66,46 @@ def linear(eqlist, fxconst):
             s = replace(s, tree_form(v), tree_form("d_0"))
         row.append(s)
         m.append(row)
+        
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = simplify(expand(m[i][j]))
+            
     m = rref(m, fxconst)
+    
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
+            
     output = []
     for index, row in enumerate(m):
-        if not all(item == 0 for item in row[:-1]):
-            output.append(summation([tree_form(vl[index2])*coeff for index2, coeff in enumerate(row[:-1])])+row[-1])
-        elif row[-1] != 0:
+        if not all(item == tree_form("d_0") for item in row[:-1]):
+            output.append(summation([tree_form(vl[index2])*coeff for index2, coeff in enumerate(row[:-1])]) + row[-1])
+        elif row[-1] != tree_form("d_0"):
             return tree_form("s_false")
+            
     if len(output) == 1:
         return TreeNode("f_eq", [output[0], tree_form("d_0")])
     if len(output) == 0:
         return tree_form("s_false")
     return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
+
 def linear_solve(eq, lst=None):
     eq = simplify(eq)
     eqlist = []
-    if eq.name =="f_and" and all(child.name == "f_eq" and child.children[1] == tree_form("d_0") for child in eq.children):
+    if eq.name == "f_and" and all(child.name == "f_eq" and child.children[1] == tree_form("d_0") for child in eq.children):
         eqlist = [child.children[0] for child in eq.children]
+    elif eq.name == "f_eq" and eq.children[1] == tree_form("d_0"):
+        eqlist = [eq.children[0]]
     else:
         return eq
+        
     out = None
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: False)
     else:
         out = linear(copy.deepcopy(eqlist), lambda x: any(contain(x, item) for item in lst))
+        
     if out is None:
         return None
     return simplify(out)

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.4
+Version: 2.2.6
 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: more_itertools
-Requires-Dist: schemdraw
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
@@ -438,7 +437,6 @@ wire_4 = Edge((4, 9))
 edge_list = [wire_1, wire_2, wire_3, wire_4,ohm_5, ohm_6, ohm_7, ohm_8, ohm_8_2, ohm_10, ohm_11, ohm_20]
 graph = CircuitGraph(10, edge_list, {})
 print(compute(find_resistance(graph, 0, 9)))
-draw_circuit(graph, start=0, end=9, scale=3.0, grid_size=30)
 ```
 
 #### Output
@@ -450,7 +448,29 @@ done
 8.66474543707973
 ```
 
-#### Example Demonstration 11 (engineering graphics)
+#### Example Demonstration 11 (resistors in parallel)
+```python
+from mathai import *
+load_formula_from_file()
+wire_1 = Edge((1, 3))
+wire_2 = Edge((2, 3))
+ohm_r1 = Edge((0, 1), "resistor", parse("x"))
+ohm_r2 = Edge((0, 2), "resistor", parse("y"))
+edge_list = [wire_1, ohm_r1, ohm_r2, wire_2]
+graph = CircuitGraph(4, edge_list, {})
+print(fraction(find_resistance(graph, 0, 3)))
+```
+
+#### Output
+
+```
+loading formulas from file...
+done
+
+(x*y)/(x+y)
+```
+
+#### Example Demonstration 12 (engineering graphics)
 ```python
 from mathai import *
 # (z,y) is dash, a'b' is front view
@@ -467,7 +487,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 +497,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 +540,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 +557,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.6}/mathai.egg-info/requires.txt

@@ -1,2 +1 @@
 more_itertools
-schemdraw

{mathai-2.2.4 → mathai-2.2.6}/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.6",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
@@ -13,7 +13,6 @@ setup(
     },
     python_requires=">=3.7",
     install_requires=[
-        "more_itertools",
-	"schemdraw"
+        "more_itertools"
     ],
 )