noshot 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

noshot/data/ML TS XAI/AIDS/12. Logistic Regression/hours_scores_records.csv

@@ -1,101 +0,0 @@
-Hours,Scores
-2.5,21.0
-5.1,47.0
-3.2,27.0
-8.5,74.0
-3.5,30.0
-5.8,60.0
-4.4,44.0
-6.1,63.0
-3.7,37.0
-8.0,84.0
-8.5,41.0
-5.8,73.0
-7.0,53.0
-9.4,68.0
-8.7,56.0
-3.2,63.0
-6.9,49.0
-4.8,84.0
-4.9,51.0
-5.9,57.0
-5.4,86.0
-7.9,22.0
-6.5,23.0
-5.3,68.0
-5.9,25.0
-5.7,87.0
-7.9,40.0
-4.7,34.0
-5.7,87.0
-3.4,78.0
-0.2,86.0
-6.3,67.0
-6.7,32.0
-3.7,87.0
-9.4,43.0
-2.3,65.0
-5.2,68.0
-4.7,46.0
-8.0,61.0
-7.9,67.0
-5.4,56.0
-5.8,27.0
-3.4,55.0
-1.3,75.0
-4.4,35.0
-5.4,46.0
-7.4,40.0
-7.4,86.0
-4.3,62.0
-4.5,57.0
-3.1,33.0
-2.4,59.0
-1.8,35.0
-8.8,49.0
-4.1,36.0
-4.2,62.0
-2.7,60.0
-6.6,45.0
-2.0,57.0
-4.7,27.0
-3.4,19.0
-5.8,57.0
-4.1,52.0
-2.8,61.0
-5.0,96.0
-5.9,68.0
-5.2,31.0
-5.7,71.0
-3.9,22.0
-4.4,40.0
-3.8,47.0
-4.4,83.0
-3.5,34.0
-1.8,32.0
-5.4,47.0
-4.3,35.0
-2.0,71.0
-6.0,27.0
-3.3,26.0
-5.2,40.0
-6.5,39.0
-5.3,87.0
-7.3,68.0
-2.7,50.0
-5.9,24.0
-3.8,66.0
-3.4,29.0
-4.0,18.0
-4.5,72.0
-5.2,55.0
-2.8,67.0
-6.8,55.0
-6.0,66.0
-2.1,36.0
-7.9,28.0
-8.7,62.0
-7.3,33.0
-4.7,35.0
-3.0,40.0
-7.1,49.0

noshot/data/ML TS XAI/AIDS/2. Implement A Star And MA Star/(A) Astar.ipynb

@@ -1,256 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ca1dd424-64c5-4d61-875e-a6f8a9265b3a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def display(graph, h, directed = False):\n",
-    "    graph = {u+\" \"+str(h[u]) : {v+\" \"+str(h[v]) : {'weight' : graph[u][v]} for v in graph[u]} for u in graph}\n",
-    "    g = nx.from_dict_of_dicts(graph)\n",
-    "    pos = nx.circular_layout(g)\n",
-    "    nx.draw(g, pos, with_labels = True)\n",
-    "    nx.draw_networkx_edge_labels(g, pos, edge_labels = nx.get_edge_attributes(g, 'weight'))\n",
-    "    plt.suptitle(\"AStar Search\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "def print_path(node, parent):\n",
-    "    if node != None:\n",
-    "        return print_path(parent[node], parent) + [node]\n",
-    "    return []\n",
-    "def AStar(graph, start, goal, h):\n",
-    "    queue = [start]\n",
-    "    visited = []\n",
-    "    parent = {start : None}\n",
-    "    g = {start : 0}\n",
-    "    f = {start : h[start]}\n",
-    "    while queue:\n",
-    "        queue.sort(key = lambda x : f[x])\n",
-    "        node = queue.pop(0)\n",
-    "        visited.append(node)\n",
-    "        if node == goal:\n",
-    "            print(f\"Result(AStar {start} to {goal}):\",print_path(node, parent),\"Path cost =\",g[node])\n",
-    "            return True\n",
-    "        for adj in graph[node]:\n",
-    "            if adj not in visited:\n",
-    "                gcost = g[node] + graph[node][adj]\n",
-    "                fcost = gcost + h[adj]\n",
-    "                if adj not in queue:\n",
-    "                    queue.append(adj)\n",
-    "                elif fcost > f[adj]:\n",
-    "                    continue\n",
-    "                g[adj] = gcost\n",
-    "                f[adj] = fcost\n",
-    "                parent[adj] = node\n",
-    "    print(f\"Result(AStar {start} to {goal}): No Solution\")\n",
-    "    return False\n",
-    "def get_graph(directed = False):\n",
-    "    graph = {}\n",
-    "    heuristic = {}\n",
-    "    print(\"Enter Node Adjacency Pair\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split(maxsplit = 2)\n",
-    "        u, heuristic[u] = x[0], int(x[1])\n",
-    "        adj = [v.strip(' ()') for v in x[2].strip('[]').split(',') if v] if len(x) == 3 else [] \n",
-    "        adj = {v : int(w) for v, w in zip(adj[::2],adj[1::2])}\n",
-    "        graph[u] = graph.get(u, {}) | adj\n",
-    "        for v, w in adj.items():\n",
-    "            graph[v] = graph.get(v, {}) | ({u : w} if not directed else {})\n",
-    "        x = input()\n",
-    "    return graph, heuristic\n",
-    "def example():\n",
-    "    graph = {\"A\" : {\"B\":9,\"C\":4,\"D\":7},\n",
-    "             \"B\" : {\"A\":9,\"E\":11},\n",
-    "             \"C\" : {\"A\":4,\"E\":17,\"F\":12},\n",
-    "             \"D\" : {\"A\":7,\"F\":14},\n",
-    "             \"E\" : {\"B\":11,\"G\":5,\"C\":17},\n",
-    "             \"F\" : {\"D\":14,\"C\":12,\"G\":9},\n",
-    "             \"G\" : {\"E\":5,\"F\":9}}\n",
-    "    heuristic = {\"A\":21,\"B\":14,\"C\":18,\"D\":18,\"E\":5,\"F\":8,\"G\":0}\n",
-    "    print(\"Heuristic: \",heuristic)\n",
-    "    print(graph)\n",
-    "    display(graph, heuristic)\n",
-    "    AStar(graph, \"A\", \"G\", heuristic)\n",
-    "\n",
-    "def main():\n",
-    "    #example();return #Uncomment to run the example\n",
-    "    graph, h = get_graph(directed = False)#undirected graph\n",
-    "    source, goal = input(\"Enter source and goal: \").split()\n",
-    "    display(graph, h, directed = False)\n",
-    "    print(\"Heuristic: \",h)\n",
-    "    print(graph)\n",
-    "    AStar(graph, source, goal, h)\n",
-    "\n",
-    "    #Sample output (Square brackets [] are optional)\n",
-    "    #Enter Node Adjacency Pair\n",
-    "    #PRESS ENTER TO STOP]\n",
-    "    #A 21 [(B,9),(C,4),(D,7)]\n",
-    "    #B 14 [(E,11)]\n",
-    "    #C 18 [(E,17),(F,12)]\n",
-    "    #D 18 [(F,14)]\n",
-    "    #E 5 [(G,5)]\n",
-    "    #F 8 [(G,9)]\n",
-    "    #G 0 []\n",
-    " \n",
-    "    #Enter source and goal:  A G\n",
-    "    #Result(AStar A to G): ['A', 'B', 'E', 'G'] Path cost = 25\n",
-    "main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "81ac2a79-e388-4cab-9b48-0ec4ebcf4591",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def display(graph, h, directed = False):\n",
-    "    graph = {u+\" \"+str(h[u]) : {v+\" \"+str(h[v]) : {'weight' : graph[u][v]} for v in graph[u]} for u in graph}\n",
-    "    g = nx.from_dict_of_dicts(graph)\n",
-    "    pos = nx.circular_layout(g)\n",
-    "    nx.draw(g, pos, with_labels = True)\n",
-    "    nx.draw_networkx_edge_labels(g, pos, edge_labels = nx.get_edge_attributes(g, 'weight'))\n",
-    "    plt.suptitle(\"AStar Search\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "def print_path(node, parent):\n",
-    "    if node != None:\n",
-    "        return print_path(parent[node], parent) + [node]\n",
-    "    return []\n",
-    "def AStar(graph, start, goal, h):\n",
-    "    queue = [start]\n",
-    "    visited = []\n",
-    "    parent = {start : None}\n",
-    "    g = {start : 0}\n",
-    "    f = {start : h[start]}\n",
-    "    while queue:\n",
-    "        queue.sort(key = lambda x : f[x])\n",
-    "        node = queue.pop(0)\n",
-    "        visited.append(node)\n",
-    "        if node == goal:\n",
-    "            print(f\"Result(AStar {start} to {goal}):\",print_path(node, parent),\"Path cost =\",g[node])\n",
-    "            return True\n",
-    "        for adj in graph[node]:\n",
-    "            if adj not in visited:\n",
-    "                gcost = g[node] + graph[node][adj]\n",
-    "                fcost = gcost + h[adj]\n",
-    "                if adj not in queue:\n",
-    "                    queue.append(adj)\n",
-    "                elif fcost > f[adj]:\n",
-    "                    continue\n",
-    "                g[adj] = gcost\n",
-    "                f[adj] = fcost\n",
-    "                parent[adj] = node\n",
-    "    print(f\"Result(AStar {start} to {goal}): No Solution\")\n",
-    "    return False\n",
-    "def get_graph(directed = False):\n",
-    "    graph = {}\n",
-    "    heuristic = {}\n",
-    "    \n",
-    "    print(\"Enter (node, heuristic)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split()\n",
-    "        u, heuristic[u] = x[0], int(x[1])\n",
-    "        graph[u] = graph.get(u, {})\n",
-    "        x = input()\n",
-    "    \n",
-    "    print(\"Enter edge (u, v, weight)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split(maxsplit = 1)\n",
-    "        u, adj = x[0], [v.strip(' ()') for v in x[1].strip('[]').split(',') if v] \n",
-    "        if len(adj) == 1:\n",
-    "            v, w = adj[0].split()\n",
-    "            adj = {v : int(w)}\n",
-    "        else:\n",
-    "            adj = {v : int(w) for v, w in zip(adj[::2],adj[1::2])}\n",
-    "        graph[u] = graph.get(u, {}) | adj\n",
-    "        for v, w in adj.items():\n",
-    "            graph[v] = graph.get(v, {}) | ({u : w} if not directed else {})\n",
-    "        x = input()\n",
-    "    return graph, heuristic\n",
-    "def example():\n",
-    "    graph = {\"A\" : {\"B\":9,\"C\":4,\"D\":7},\n",
-    "             \"B\" : {\"A\":9,\"E\":11},\n",
-    "             \"C\" : {\"A\":4,\"E\":17,\"F\":12},\n",
-    "             \"D\" : {\"A\":7,\"F\":14},\n",
-    "             \"E\" : {\"B\":11,\"G\":5,\"C\":17},\n",
-    "             \"F\" : {\"D\":14,\"C\":12,\"G\":9},\n",
-    "             \"G\" : {\"E\":5,\"F\":9}}\n",
-    "    heuristic = {\"A\":21,\"B\":14,\"C\":18,\"D\":18,\"E\":5,\"F\":8,\"G\":0}\n",
-    "    print(\"Heuristic: \",heuristic)\n",
-    "    print(graph)\n",
-    "    display(graph, heuristic)\n",
-    "    AStar(graph, \"A\", \"G\", heuristic)\n",
-    "\n",
-    "def main():\n",
-    "    #example();return #Uncomment to run the example\n",
-    "    graph, h = get_graph(directed = False)#undirected graph\n",
-    "    source, goal = input(\"Enter source and goal: \").split()\n",
-    "    display(graph, h, directed = False)\n",
-    "    print(\"Heuristic: \",h)\n",
-    "    print(graph)\n",
-    "    AStar(graph, source, goal, h)\n",
-    "\n",
-    "    #Sample output\n",
-    "    #Enter (node, heuristic)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A 21\n",
-    "    #B 14\n",
-    "    #C 18\n",
-    "    #D 18\n",
-    "    #E 5\n",
-    "    #F 8\n",
-    "    #G 0\n",
-    " \n",
-    "    #Enter edge (u, v, weight)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A B 9\n",
-    "    #A C 4\n",
-    "    #A D 7\n",
-    "    #B E 11\n",
-    "    #C E 17\n",
-    "    #C F 12\n",
-    "    #D F 14\n",
-    "    #E G 5\n",
-    "    #F G 9\n",
-    " \n",
-    "    #Enter source and goal:  A G\n",
-    "    #Result(AStar A to G): ['A', 'B', 'E', 'G'] Path cost = 25\n",
-    "main()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

noshot/data/ML TS XAI/AIDS/2. Implement A Star And MA Star/(B) IDAstar.ipynb

@@ -1,157 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e9bef27c-59b6-431a-b88b-ceafb10c9680",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def display(graph, h, directed = False):\n",
-    "    graph = {u+\" \"+str(h[u]) : {v+\" \"+str(h[v]) : {'weight' : graph[u][v]} for v in graph[u]} for u in graph}\n",
-    "    g = nx.from_dict_of_dicts(graph)\n",
-    "    pos = nx.circular_layout(g)\n",
-    "    nx.draw(g, pos, with_labels = True)\n",
-    "    nx.draw_networkx_edge_labels(g, pos, edge_labels = nx.get_edge_attributes(g, 'weight'))\n",
-    "    plt.suptitle(\"IDAStar Search\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "def print_path(node, parent):\n",
-    "    if node != None:\n",
-    "        return print_path(parent[node], parent) + [node]\n",
-    "    return []\n",
-    "INF = float('inf')\n",
-    "def IDAStar(graph, start, goal, h):    \n",
-    "    parent = {start : None}    \n",
-    "    th = h[start]\n",
-    "    while True:\n",
-    "        result, new_th = recursive_dfs(graph, parent, start, goal, 0, h, th)\n",
-    "        if result is not None:\n",
-    "            result = print_path(result, parent)\n",
-    "            cost = sum([graph[n1][n2] for n1, n2 in zip(result,result[1:])])\n",
-    "            print(f\"Result(IDAStar {start} to {goal}):\",result,\"Path cost =\",cost)\n",
-    "            return\n",
-    "        elif new_th == INF:\n",
-    "            print(f\"Result(IDAStar {start} to {goal}): failure\")\n",
-    "            return\n",
-    "        th = new_th\n",
-    "def recursive_dfs(graph, parent, node, goal, g, h, th):\n",
-    "    f = g + h[node]\n",
-    "    if f > th:\n",
-    "        return None, f\n",
-    "    if node == goal:\n",
-    "        return node, f\n",
-    "    min_th = INF\n",
-    "    for adj in graph[node]:\n",
-    "        result, temp_th = recursive_dfs(graph, parent, adj, goal, g + graph[node][adj], h, th)\n",
-    "        if result is not None:\n",
-    "            parent[adj] = node\n",
-    "            return result, temp_th\n",
-    "        elif temp_th < min_th:\n",
-    "            min_th = temp_th\n",
-    "    return None, min_th\n",
-    "def get_graph(directed = False):\n",
-    "    graph = {}\n",
-    "    heuristic = {}\n",
-    "    \n",
-    "    print(\"Enter (node, heuristic)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split()\n",
-    "        u, heuristic[u] = x[0], int(x[1])\n",
-    "        graph[u] = graph.get(u, {})\n",
-    "        x = input()\n",
-    "    \n",
-    "    print(\"Enter edge (u, v, weight)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split(maxsplit = 1)\n",
-    "        u, adj = x[0], [v.strip(' ()') for v in x[1].strip('[]').split(',') if v] \n",
-    "        if len(adj) == 1:\n",
-    "            v, w = adj[0].split()\n",
-    "            adj = {v : int(w)}\n",
-    "        else:\n",
-    "            adj = {v : int(w) for v, w in zip(adj[::2],adj[1::2])}\n",
-    "        graph[u] = graph.get(u, {}) | adj\n",
-    "        for v, w in adj.items():\n",
-    "            graph[v] = graph.get(v, {}) | ({u : w} if not directed else {})\n",
-    "        x = input()\n",
-    "    return graph, heuristic\n",
-    "def example():\n",
-    "    graph = {\"A\" : {\"B\":9,\"C\":4,\"D\":7},\n",
-    "             \"B\" : {\"A\":9,\"E\":11},\n",
-    "             \"C\" : {\"A\":4,\"E\":17,\"F\":12},\n",
-    "             \"D\" : {\"A\":7,\"F\":14},\n",
-    "             \"E\" : {\"B\":11,\"G\":5,\"C\":17},\n",
-    "             \"F\" : {\"D\":14,\"C\":12,\"G\":9},\n",
-    "             \"G\" : {\"E\":5,\"F\":9}}\n",
-    "    heuristic = {\"A\":21,\"B\":14,\"C\":18,\"D\":18,\"E\":5,\"F\":8,\"G\":0}\n",
-    "    print(\"Heuristic: \",heuristic)\n",
-    "    print(graph)\n",
-    "    display(graph, heuristic)\n",
-    "    IDAStar(graph, \"A\", \"G\", heuristic)\n",
-    "\n",
-    "def main():\n",
-    "    #example();return #Uncomment to run the example\n",
-    "    graph, h = get_graph(directed = False)#undirected graph\n",
-    "    source, goal = input(\"Enter source and goal: \").split()\n",
-    "    display(graph, h, directed = False)\n",
-    "    print(\"Heuristic: \",h)\n",
-    "    print(graph)\n",
-    "    IDAStar(graph, source, goal, h)\n",
-    "\n",
-    "    #Sample output\n",
-    "    #Enter (node, heuristic)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A 21\n",
-    "    #B 14\n",
-    "    #C 18\n",
-    "    #D 18\n",
-    "    #E 5\n",
-    "    #F 8\n",
-    "    #G 0\n",
-    " \n",
-    "    #Enter edge (u, v, weight)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A B 9\n",
-    "    #A C 4\n",
-    "    #A D 7\n",
-    "    #B E 11\n",
-    "    #C E 17\n",
-    "    #C F 12\n",
-    "    #D F 14\n",
-    "    #E G 5\n",
-    "    #F G 9\n",
-    " \n",
-    "    #Enter source and goal:  A G\n",
-    "    #Result(IDAStar A to G): ['A', 'B', 'E', 'G'] Path cost = 25\n",
-    "main()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

noshot/data/ML TS XAI/AIDS/2. Implement A Star And MA Star/(C) SMAstar.ipynb

@@ -1,178 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f9d6ed77-2aeb-4e73-ba88-388457f5332c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "def display(graph, h, directed = False):\n",
-    "    graph = {u+\" \"+str(h[u]) : {v+\" \"+str(h[v]) : {'weight' : graph[u][v]} for v in graph[u]} for u in graph}\n",
-    "    g = nx.from_dict_of_dicts(graph)\n",
-    "    pos = nx.circular_layout(g)\n",
-    "    nx.draw(g, pos, with_labels = True)\n",
-    "    nx.draw_networkx_edge_labels(g, pos, edge_labels = nx.get_edge_attributes(g, 'weight'))\n",
-    "    plt.suptitle(\"SMAStar Search\")\n",
-    "    plt.show()\n",
-    "    plt.clf()\n",
-    "def print_path(node, parent):\n",
-    "    if node != None:\n",
-    "        return print_path(parent[node], parent) + [node]\n",
-    "    return []\n",
-    "def SMAStar(graph, start, goal, h, bound):\n",
-    "    queue = [start]\n",
-    "    visited = []\n",
-    "    parent = {start : None}\n",
-    "    g = {start : 0}\n",
-    "    f = {start : h[start]}\n",
-    "    backup = {}\n",
-    "    while queue:\n",
-    "        queue.sort(key = lambda x : f[x])\n",
-    "        node = queue.pop(0)\n",
-    "        visited.append(node)\n",
-    "        if node == goal:\n",
-    "            print(f\"Result(SMAStar {start} to {goal}):\",print_path(node, parent),\"Path cost =\",g[node],\"Bound =\",bound)\n",
-    "            return True\n",
-    "        successors = []\n",
-    "        for adj in graph[node]:\n",
-    "            if adj in visited:\n",
-    "                continue\n",
-    "            gcost = g[node] + graph[node][adj]\n",
-    "            fcost = gcost + h[adj]\n",
-    "            if adj in queue:\n",
-    "                if fcost >= f[adj]:\n",
-    "                    continue\n",
-    "            elif len(queue) < bound:\n",
-    "                    queue.append(adj)\n",
-    "            else:\n",
-    "                worst = max(queue, key = lambda x : f[x])\n",
-    "                if fcost < f[worst]:\n",
-    "                    backup[worst] = f[worst]\n",
-    "                    queue.remove(worst)\n",
-    "                    queue.append(adj)\n",
-    "                else:\n",
-    "                    continue\n",
-    "            g[adj] = gcost\n",
-    "            f[adj] = fcost\n",
-    "            parent[adj] = node\n",
-    "            successors.append(adj)\n",
-    "        if not successors and node in backup:\n",
-    "            f[node] = backup[node]\n",
-    "        elif not successors:\n",
-    "            f[node] = float('inf')\n",
-    "    print(f\"Result(SMAStar {start} to {goal}): No Solution Bound = \",bound)\n",
-    "    return False\n",
-    "def get_graph(directed = False):\n",
-    "    graph = {}\n",
-    "    heuristic = {}\n",
-    "    \n",
-    "    print(\"Enter (node, heuristic)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split()\n",
-    "        u, heuristic[u] = x[0], int(x[1])\n",
-    "        graph[u] = graph.get(u, {})\n",
-    "        x = input()\n",
-    "    \n",
-    "    print(\"Enter edge (u, v, weight)\")\n",
-    "    print(\"[PRESS ENTER TO STOP]\")\n",
-    "    x = input()\n",
-    "    while x:\n",
-    "        x = x.split(maxsplit = 1)\n",
-    "        u, adj = x[0], [v.strip(' ()') for v in x[1].strip('[]').split(',') if v] \n",
-    "        if len(adj) == 1:\n",
-    "            v, w = adj[0].split()\n",
-    "            adj = {v : int(w)}\n",
-    "        else:\n",
-    "            adj = {v : int(w) for v, w in zip(adj[::2],adj[1::2])}\n",
-    "        graph[u] = graph.get(u, {}) | adj\n",
-    "        for v, w in adj.items():\n",
-    "            graph[v] = graph.get(v, {}) | ({u : w} if not directed else {})\n",
-    "        x = input()\n",
-    "    return graph, heuristic\n",
-    "def example():\n",
-    "    graph = {\"A\" : {\"B\":9,\"C\":4,\"D\":7},\n",
-    "             \"B\" : {\"A\":9,\"E\":11},\n",
-    "             \"C\" : {\"A\":4,\"E\":17,\"F\":12},\n",
-    "             \"D\" : {\"A\":7,\"F\":14},\n",
-    "             \"E\" : {\"B\":11,\"G\":5,\"C\":17},\n",
-    "             \"F\" : {\"D\":14,\"C\":12,\"G\":9},\n",
-    "             \"G\" : {\"E\":5,\"F\":9}}\n",
-    "    heuristic = {\"A\":21,\"B\":14,\"C\":18,\"D\":18,\"E\":5,\"F\":8,\"G\":0}\n",
-    "    print(\"Heuristic: \",heuristic)\n",
-    "    print(graph)\n",
-    "    display(graph, heuristic)\n",
-    "    SMAStar(graph, \"A\", \"G\", heuristic, 4)\n",
-    "\n",
-    "def main():\n",
-    "    #example();return #Uncomment to run the example\n",
-    "    graph, h = get_graph(directed = False)#undirected graph\n",
-    "    source, goal, bound = input(\"Enter source and goal and bound: \").split()\n",
-    "    display(graph, h, directed = False)\n",
-    "    print(\"Heuristic: \",h)\n",
-    "    print(graph)\n",
-    "    SMAStar(graph, source, goal, h, int(bound))\n",
-    "\n",
-    "    #Sample output\n",
-    "    #Enter (node, heuristic)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A 21\n",
-    "    #B 14\n",
-    "    #C 18\n",
-    "    #D 18\n",
-    "    #E 5\n",
-    "    #F 8\n",
-    "    #G 0\n",
-    " \n",
-    "    #Enter edge (u, v, weight)\n",
-    "    #[PRESS ENTER TO STOP]\n",
-    "    #A B 9\n",
-    "    #A C 4\n",
-    "    #A D 7\n",
-    "    #B E 11\n",
-    "    #C E 17\n",
-    "    #C F 12\n",
-    "    #D F 14\n",
-    "    #E G 5\n",
-    "    #F G 9\n",
-    " \n",
-    "    #Enter source and goal:  A G 4\n",
-    "    #Result(SMAStar A to G): ['A', 'C', 'F', 'G'] Path cost = 25 Bound = 4\n",
-    "main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c9058a95-e899-457a-aff4-a5bed47bca86",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}