mathref 0.1.0__py3-none-any.whl

mathref/__main__.py

@@ -0,0 +1,48 @@
+from importlib.resources import files
+
+
+def main():
+    folder = files("mathref").joinpath("maatracos")
+
+    mathrefs = sorted(
+        (
+            p for p in folder.iterdir()
+            if p.name.lower().endswith((".txt", ".py"))
+        ),
+        key=lambda p: p.name
+    )
+
+    if not mathrefs:
+        print("No MathRef files found.")
+        return
+
+    print("\n===== MATHREF =====")
+    print("Collection!\n")
+
+    for i, mathref in enumerate(mathrefs, start=1):
+        print(f"{i}. {mathref.name}")
+
+    while True:
+        choice = input("\nEnter number (0 to exit): ").strip()
+
+        if choice == "0":
+            print("Goodbye!")
+            break
+
+        if not choice.isdigit():
+            print("Please enter a valid number.")
+            continue
+
+        number = int(choice)
+
+        if not 1 <= number <= len(mathrefs):
+            print("MathRef not found.")
+            continue
+
+        print(f"\n===== {mathrefs[number - 1].name} =====\n")
+        print(mathrefs[number - 1].read_text(encoding="utf-8"))
+        print()
+
+
+if __name__ == "__main__":
+    main()

mathref/mathref/01_maatraco.py

@@ -0,0 +1,258 @@
+
+
+
+import heapq
+from collections import deque
+
+def read_nums():
+    return list(map(int, input("Enter numbers separated by spaces: ").split()))
+
+# 1. Sorting: remember "sort()" fallback; these are manual algorithms.
+def sorting():
+    a = read_nums()
+    print("1 Bubble  2 Selection  3 Insertion  4 Merge  5 Quick")
+    ch = input("Choice: ")
+    if ch == "1":
+        for i in range(len(a)):
+            for j in range(len(a)-i-1):
+                if a[j] > a[j+1]:
+                    a[j], a[j+1] = a[j+1], a[j]
+    elif ch == "2":
+        for i in range(len(a)):
+            m = i
+            for j in range(i+1, len(a)):
+                if a[j] < a[m]: m = j
+            a[i], a[m] = a[m], a[i]
+    elif ch == "3":
+        for i in range(1, len(a)):
+            key, j = a[i], i-1
+            while j >= 0 and a[j] > key:
+                a[j+1] = a[j]; j -= 1
+            a[j+1] = key
+    elif ch == "4":
+        if len(a) > 1:
+            m = len(a)//2
+            left, right = a[:m], a[m:]
+            # recursive merge sort
+            def ms(x):
+                if len(x) <= 1: return x
+                m = len(x)//2
+                L, R = ms(x[:m]), ms(x[m:])
+                out = []
+                while L and R: out.append(L.pop(0) if L[0] <= R[0] else R.pop(0))
+                return out + L + R
+            a = ms(a)
+    elif ch == "5":
+        def qs(x):
+            if len(x) <= 1: return x
+            p = x[-1]
+            return qs([v for v in x[:-1] if v <= p]) + [p] + qs([v for v in x[:-1] if v > p])
+        a = qs(a)
+    print("Sorted:", a)
+
+# 2. Matrix multiplication (standard O(n^3))
+def matrix():
+    n = int(input("Square matrix size n: "))
+    print("Enter matrix A row by row:")
+    A = [list(map(int, input().split())) for _ in range(n)]
+    print("Enter matrix B row by row:")
+    B = [list(map(int, input().split())) for _ in range(n)]
+    C = [[sum(A[i][k]*B[k][j] for k in range(n)) for j in range(n)] for i in range(n)]
+    print("Result:")
+    for row in C: print(row)
+
+# 3. Hiring problem / randomized-style candidate selection
+def hiring():
+    scores = read_nums()
+    best, hired = -1, []
+    for i, score in enumerate(scores):
+        if score > best:
+            hired.append((i+1, score)); best = score
+    print("Candidates (position, score):", scores)
+    print("Hired record-breakers:", hired)
+    print("Total hires:", len(hired))
+
+# 4. Order statistics and counting sort
+def order_stats():
+    a = read_nums()
+    print("1 k-th smallest/largest  2 Counting sort (non-negative only)")
+    ch = input("Choice: ")
+    if ch == "1":
+        k = int(input("Enter k (1 = smallest/largest): "))
+        if not 1 <= k <= len(a): print("Invalid k"); return
+        s = sorted(a)
+        print("k-th smallest:", s[k-1], "| k-th largest:", s[-k])
+    else:
+        if min(a) < 0: print("Counting sort needs non-negative integers"); return
+        out = []
+        for v in range(max(a)+1): out += [v] * a.count(v)
+        print("Counting sort:", out)
+
+# 5. Binary tree traversal and node counts
+class Node:
+    def __init__(self, x):
+        self.x, self.left, self.right = x, None, None
+
+def trees():
+    # Simple fixed tree; change node values/links for a question.
+    r = Node(10); r.left = Node(5); r.right = Node(15)
+    r.left.left = Node(2); r.left.right = Node(7); r.right.right = Node(20)
+    def ino(n): return ino(n.left)+[n.x]+ino(n.right) if n else []
+    def pre(n): return [n.x]+pre(n.left)+pre(n.right) if n else []
+    def post(n): return post(n.left)+post(n.right)+[n.x] if n else []
+    def count(n): return 0 if not n else 1+count(n.left)+count(n.right)
+    def leaves(n): return 0 if not n else (1 if not n.left and not n.right else leaves(n.left)+leaves(n.right))
+    print("Inorder LNR:", ino(r)); print("Preorder NLR:", pre(r)); print("Postorder LRN:", post(r))
+    print("Total nodes:", count(r), "| Leaf nodes:", leaves(r))
+
+# Common sample weighted graph for BFS/DFS/Dijkstra/Prim/Kruskal.
+def get_graph():
+    return {
+        'A': {'B': 4, 'C': 2}, 'B': {'A': 4, 'C': 1, 'D': 5},
+        'C': {'A': 2, 'B': 1, 'D': 8, 'E': 10}, 'D': {'B': 5, 'C': 8, 'E': 2},
+        'E': {'C': 10, 'D': 2}
+    }
+
+# 6. Graph algorithms
+def graphs():
+    g = get_graph()
+    s = input("Start vertex (A/B/C/D/E): ").upper()
+    print("1 BFS  2 DFS  3 Dijkstra shortest distances  4 Prim MST  5 Kruskal MST")
+    ch = input("Choice: ")
+    if ch == "1":
+        q, seen, order = deque([s]), {s}, []
+        while q:
+            v = q.popleft(); order.append(v)
+            for u in g[v]:
+                if u not in seen: seen.add(u); q.append(u)
+        print("BFS:", order)
+    elif ch == "2":
+        seen, order = set(), []
+        def dfs(v):
+            seen.add(v); order.append(v)
+            for u in g[v]:
+                if u not in seen: dfs(u)
+        dfs(s); print("DFS:", order)
+    elif ch == "3":
+        d = {v: float("inf") for v in g}; d[s] = 0; pq = [(0, s)]
+        while pq:
+            cost, v = heapq.heappop(pq)
+            if cost != d[v]: continue
+            for u, w in g[v].items():
+                if cost+w < d[u]: d[u] = cost+w; heapq.heappush(pq, (d[u], u))
+        print("Shortest distances:", d)
+    else:
+        edges = sorted((w, v, u) for v in g for u, w in g[v].items() if v < u)
+        if ch == "4":  # Prim
+            seen, chosen = {s}, []
+            while len(seen) < len(g):
+                options = [(w, v, u) for v in seen for u, w in g[v].items() if u not in seen]
+                if not options: break
+                w, v, u = min(options); chosen.append((v, u, w)); seen.add(u)
+        else:  # Kruskal
+            parent = {v: v for v in g}
+            def find(x):
+                while parent[x] != x: x = parent[x]
+                return x
+            chosen = []
+            for w, v, u in edges:
+                a, b = find(v), find(u)
+                if a != b: parent[a] = b; chosen.append((v, u, w))
+        print("MST edges:", chosen, "| Total weight:", sum(e[2] for e in chosen))
+
+# 7. String matching: works as a safe fallback for Naive, KMP/Rabin-Karp/Boyer-Moore questions
+def strings():
+    text = input("Enter text: ")
+    pat = input("Enter pattern: ")
+    found = [i for i in range(len(text)-len(pat)+1) if text[i:i+len(pat)] == pat]
+    print("Pattern positions (0-based):", found if pat else [])
+
+# 8. Dynamic programming: LCS, rod cutting, matrix-chain cost
+def dynamic():
+    print("1 LCS  2 Rod cutting  3 Matrix-chain multiplication")
+    ch = input("Choice: ")
+    if ch == "1":
+        a, b = input("String 1: "), input("String 2: ")
+        dp = [[0]*(len(b)+1) for _ in range(len(a)+1)]
+        for i in range(1, len(a)+1):
+            for j in range(1, len(b)+1):
+                dp[i][j] = dp[i-1][j-1]+1 if a[i-1] == b[j-1] else max(dp[i-1][j], dp[i][j-1])
+        print("LCS length:", dp[-1][-1])
+    elif ch == "2":
+        p = read_nums(); n = int(input("Rod length (<= number of prices): "))
+        dp = [0]*(n+1)
+        for i in range(1, n+1):
+            dp[i] = max(p[j]+dp[i-j-1] for j in range(i))
+        print("Maximum revenue:", dp[n])
+    else:
+        dims = read_nums()  # dimensions, e.g. 10 20 30 40
+        n = len(dims)-1; dp = [[0]*n for _ in range(n)]
+        for length in range(2, n+1):
+            for i in range(n-length+1):
+                j = i+length-1
+                dp[i][j] = min(dp[i][k]+dp[k+1][j]+dims[i]*dims[k+1]*dims[j+1] for k in range(i,j))
+        print("Minimum multiplications:", dp[0][n-1])
+
+# 9. Greedy: activity selection (Huffman is more involved; this is a reusable greedy pattern)
+def greedy():
+    n = int(input("Number of activities: "))
+    acts = []
+    for i in range(n):
+        start, finish = map(int, input(f"Activity {i+1} start finish: ").split())
+        acts.append((finish, start, i+1))
+    acts.sort()
+    chosen, end = [], -1
+    for finish, start, name in acts:
+        if start >= end: chosen.append(name); end = finish
+    print("Selected activity numbers:", chosen)
+
+# 10. Approximation: set cover / vertex cover approximation
+def approximation():
+    print("1 Set cover  2 Vertex cover")
+    ch = input("Choice: ")
+    if ch == "1":
+        universe = set(read_nums())
+        n = int(input("Number of sets: "))
+        sets = {}
+        for i in range(n): sets[f"S{i+1}"] = set(read_nums())
+        chosen = []
+        while universe:
+            best = max(sets, key=lambda k: len(sets[k] & universe))
+            covered = sets[best] & universe
+            if not covered: break
+            chosen.append(best); universe -= covered
+        print("Chosen sets:", chosen, "| Uncovered:", universe)
+    else:
+        n = int(input("Number of edges: "))
+        edges = []
+        for _ in range(n): edges.append(input("Edge u v: ").split())
+        cover = set()
+        while edges:
+            degree = {}
+            for u, v in edges:
+                degree[u] = degree.get(u, 0)+1; degree[v] = degree.get(v, 0)+1
+            v = max(degree, key=degree.get); cover.add(v)
+            edges = [(u, w) for u, w in edges if u != v and w != v]
+        print("Approximate vertex cover:", cover)
+
+def main():
+    while True:
+        print("\\n=== AOA MASTER PRACTICAL ===")
+        print("1 Sorting  2 Matrix multiplication  3 Hiring problem")
+        print("4 Order statistics/counting sort  5 Binary tree")
+        print("6 Graphs  7 String matching  8 Dynamic programming")
+        print("9 Greedy activity selection  10 Approximation")
+        print("0 Exit")
+        ch = input("Select practical: ")
+        if ch == "0": break
+        try:
+            {"1": sorting, "2": matrix, "3": hiring, "4": order_stats,
+             "5": trees, "6": graphs, "7": strings, "8": dynamic,
+             "9": greedy, "10": approximation}[ch]()
+        except KeyError:
+            print("Choose a valid menu number.")
+        except (ValueError, IndexError, KeyError) as e:
+            print("Input issue - check the values and try again.", e)
+
+if __name__ == "__main__":
+    main()

mathref/mathref/02_mathref.py

@@ -0,0 +1,21 @@
+
+import os
+from google import genai
+from google.genai import types
+
+os.environ["GEMINI_API_KEY"] = ""
+
+user_prompt = "write a simple minimal without comments only code"
+
+client = genai.Client()
+response = client.models.generate_content(
+    model="gemini-3.6-flash",
+    contents=user_prompt,
+    config=types.GenerateContentConfig(
+        automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True)
+    )
+)
+
+print(response.text)
+
+pip install google-genai

mathref-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: mathref
+Version: 0.1.0
+Summary: A collection of numbered Python math references
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+A Python package containing numbered practical notes and code.
+
+## Installation
+python -m pip install maatraco-kit
+
+## Run in Python IDLE
+import runpy
+runpy.run_module("maatracos", run_name="__main__")
+
+Enter a maatraco number to display its contents. Enter 0 to exit.

mathref-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mathref/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mathref/__main__.py,sha256=uLvaPc_OzOm-nGmCYSQC7njtd-uPgVommE9v0jB35Os,1138
+mathref/mathref/01_maatraco.py,sha256=JqeK0caM-5rqPvD9XnRrs149hnvdzSmre8K-1w7kJKI,10245
+mathref/mathref/02_mathref.py,sha256=0XLFeLV8CEu26AmgfaN1oDuzC1YXYzE3KLrRu2uOS4A,496
+mathref-0.1.0.dist-info/METADATA,sha256=V5W-H3kp7Uyaank2IZgRzw8STV4kuDovEjfLQQ7QmaE,458
+mathref-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mathref-0.1.0.dist-info/top_level.txt,sha256=Px13WTO63oOVImjOp-rtXBulwCNF0_ys-6epvo6w5nA,8
+mathref-0.1.0.dist-info/RECORD,,

mathref-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mathref-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mathref