mathai 2.2.5__tar.gz → 2.2.6__tar.gz

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.5
+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

{mathai-2.2.5 → 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

{mathai-2.2.5 → 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.5 → 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.5 → 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.5 → mathai-2.2.6}/mathai.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.2.5
+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

{mathai-2.2.5 → mathai-2.2.6}/mathai.egg-info/requires.txt

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

{mathai-2.2.5 → 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.5",
+    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"
     ],
 )