optivlsi 0.1.0__tar.gz

optivlsi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rohan Rajesh Kalbag, Neeraj Prabhu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

optivlsi-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include optivlsi *.py
+recursive-include tests *.py
+recursive-include examples *.py
+recursive-include docs *.mdinclude LICENSE

optivlsi-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: optivlsi
+Version: 0.1.0
+Summary: High-performance VLSI CAD algorithms with Numba-accelerated implementations
+Author: Rohan Rajesh Kalbag, Neeraj Prabhu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rohankalbag/optiVLSI
+Project-URL: Repository, https://github.com/rohankalbag/optiVLSI.git
+Keywords: vlsi,cad,graph-algorithms,numba,networkx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23.5
+Requires-Dist: numba>=0.56.4
+Requires-Dist: networkx>=3.0
+Requires-Dist: matplotlib>=3.7.1
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scipy>=1.10.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0; extra == "dev"
+Dynamic: license-file
+
+# optiVLSI
+
+optiVLSI is a Python package that implements a collection of classic graph and circuit algorithms, including:
+
+- Bellman‑Ford
+- Dijkstra
+- Prim
+- Kruskal
+- Lee (maze solver)
+- BDD (binary decision diagrams)
+- Simulation engines (compiled‑code and event‑driven)
+
+The project has been refactored into a proper Python package with a modern `pyproject.toml`, type hints, comprehensive tests, documentation, and CI/CD pipelines.
+
+## Quick Start
+
+```bash
+# Install the package
+pip install optivlsi
+
+# Run a quick demo
+python -m optivlsi.lee.algorithms.lee_algorithm
+```
+
+## Documentation
+
+- [API Reference](docs/api.md)
+- [Algorithms Overview](docs/algorithms.md)
+- [Benchmarks](docs/benchmarks.md)
+
+## Contributing
+
+See the [CONTRIBUTING.md](CONTRIBUTING.md) file for guidelines.
+
+## Implemented Algorithms
+
+### Graph Algorithms
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Bellman-Ford Shortest Path | `optivlsi.bellman_ford` | Pythonic, NetworkX, Numba |
+| Dijkstra Shortest Path | `optivlsi.dijkstra` | Pythonic, NetworkX, Numba |
+| Kruskal Minimum Spanning Tree | `optivlsi.kruskal` | Pythonic (DSU), NetworkX, Numba |
+| Prim Minimum Spanning Tree | `optivlsi.prim` | Pythonic, NetworkX, Numba |
+
+### Routing
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Lee Maze Routing | `optivlsi.lee` | Pythonic BFS, NetworkX, Numba |
+
+### Digital Circuit Simulation
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Compiled-Code Simulator | `optivlsi.simulation.compiled_code` | Gate classes, Numba |
+| Event-Driven Simulator | `optivlsi.simulation.event_driven` | Event propagation, Numba |
+
+### Binary Decision Diagrams
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| ROBDD | `optivlsi.bdd` | Python, Numba |
+
+## Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=optivlsi --cov-report=term
+
+# Run benchmarks
+pytest tests/test_benchmarks.py --benchmark-only
+```
+
+## Documentation
+
+Full documentation is available in the [docs/](docs/) directory:
+
+- [API Reference](docs/api.md)
+- [Algorithm Details](docs/algorithms.md)
+
+Detailed research paper: [OptiVLSI.pdf](OptiVLSI.pdf)
+
+## Benchmarking
+
+Each algorithm module includes an `automate.py` file for automan-based benchmarking across various problem sizes. The package also provides pytest-benchmark integration for performance regression detection.
+
+## Optimization Tools Used
+
+- **Numba**: All algorithms have Numba-accelerated variants with JIT compilation
+- **Automan**: Automated simulation and benchmarking infrastructure
+- **NetworkX**: Reference implementations using standard graph library
+
+## Project Structure
+
+```
+optivlsi/                   # Main package
+├── bellman_ford/           # Bellman-Ford algorithm
+├── dijkstra/               # Dijkstra's algorithm
+├── kruskal/                # Kruskal's MST
+├── prim/                   # Prim's MST
+├── lee/                    # Lee maze routing
+├── simulation/
+│   ├── compiled_code/      # Compiled-code simulator
+│   ├── compiled_code_numba/# Numba-accelerated variant
+│   └── event_driven/       # Event-driven simulator
+├── bdd/                    # ROBDD
+└── utils/                  # Shared utilities
+bellman-ford/               # Original standalone modules
+dijkstra/                   # (preserved for reproducibility)
+kruskal/                    #
+prim/                       #
+lee-algorithm/              #
+compiled-code-simulator/    #
+event-driven-sim/           #
+ROBDD/                      #
+```
+
+## Original Research
+
+This open-source codebase started as a course project for **AE6102 - Parallel Scientific Computing and Visualization** at IIT Bombay. The original standalone research modules are preserved in their respective directories.
+
+## Collaborators
+
+- Rohan Rajesh Kalbag
+- Neeraj Prabhu
+
+## License
+
+MIT

optivlsi-0.1.0/README.md

@@ -0,0 +1,129 @@
+# optiVLSI
+
+optiVLSI is a Python package that implements a collection of classic graph and circuit algorithms, including:
+
+- Bellman‑Ford
+- Dijkstra
+- Prim
+- Kruskal
+- Lee (maze solver)
+- BDD (binary decision diagrams)
+- Simulation engines (compiled‑code and event‑driven)
+
+The project has been refactored into a proper Python package with a modern `pyproject.toml`, type hints, comprehensive tests, documentation, and CI/CD pipelines.
+
+## Quick Start
+
+```bash
+# Install the package
+pip install optivlsi
+
+# Run a quick demo
+python -m optivlsi.lee.algorithms.lee_algorithm
+```
+
+## Documentation
+
+- [API Reference](docs/api.md)
+- [Algorithms Overview](docs/algorithms.md)
+- [Benchmarks](docs/benchmarks.md)
+
+## Contributing
+
+See the [CONTRIBUTING.md](CONTRIBUTING.md) file for guidelines.
+
+## Implemented Algorithms
+
+### Graph Algorithms
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Bellman-Ford Shortest Path | `optivlsi.bellman_ford` | Pythonic, NetworkX, Numba |
+| Dijkstra Shortest Path | `optivlsi.dijkstra` | Pythonic, NetworkX, Numba |
+| Kruskal Minimum Spanning Tree | `optivlsi.kruskal` | Pythonic (DSU), NetworkX, Numba |
+| Prim Minimum Spanning Tree | `optivlsi.prim` | Pythonic, NetworkX, Numba |
+
+### Routing
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Lee Maze Routing | `optivlsi.lee` | Pythonic BFS, NetworkX, Numba |
+
+### Digital Circuit Simulation
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| Compiled-Code Simulator | `optivlsi.simulation.compiled_code` | Gate classes, Numba |
+| Event-Driven Simulator | `optivlsi.simulation.event_driven` | Event propagation, Numba |
+
+### Binary Decision Diagrams
+| Algorithm | Package | Variants |
+|-----------|---------|----------|
+| ROBDD | `optivlsi.bdd` | Python, Numba |
+
+## Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=optivlsi --cov-report=term
+
+# Run benchmarks
+pytest tests/test_benchmarks.py --benchmark-only
+```
+
+## Documentation
+
+Full documentation is available in the [docs/](docs/) directory:
+
+- [API Reference](docs/api.md)
+- [Algorithm Details](docs/algorithms.md)
+
+Detailed research paper: [OptiVLSI.pdf](OptiVLSI.pdf)
+
+## Benchmarking
+
+Each algorithm module includes an `automate.py` file for automan-based benchmarking across various problem sizes. The package also provides pytest-benchmark integration for performance regression detection.
+
+## Optimization Tools Used
+
+- **Numba**: All algorithms have Numba-accelerated variants with JIT compilation
+- **Automan**: Automated simulation and benchmarking infrastructure
+- **NetworkX**: Reference implementations using standard graph library
+
+## Project Structure
+
+```
+optivlsi/                   # Main package
+├── bellman_ford/           # Bellman-Ford algorithm
+├── dijkstra/               # Dijkstra's algorithm
+├── kruskal/                # Kruskal's MST
+├── prim/                   # Prim's MST
+├── lee/                    # Lee maze routing
+├── simulation/
+│   ├── compiled_code/      # Compiled-code simulator
+│   ├── compiled_code_numba/# Numba-accelerated variant
+│   └── event_driven/       # Event-driven simulator
+├── bdd/                    # ROBDD
+└── utils/                  # Shared utilities
+bellman-ford/               # Original standalone modules
+dijkstra/                   # (preserved for reproducibility)
+kruskal/                    #
+prim/                       #
+lee-algorithm/              #
+compiled-code-simulator/    #
+event-driven-sim/           #
+ROBDD/                      #
+```
+
+## Original Research
+
+This open-source codebase started as a course project for **AE6102 - Parallel Scientific Computing and Visualization** at IIT Bombay. The original standalone research modules are preserved in their respective directories.
+
+## Collaborators
+
+- Rohan Rajesh Kalbag
+- Neeraj Prabhu
+
+## License
+
+MIT

optivlsi-0.1.0/examples/__init__.py

@@ -0,0 +1 @@
+"""Example scripts demonstrating optiVLSI algorithm usage."""

optivlsi-0.1.0/examples/bdd_demo.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""Example: Build and evaluate a Reduced Ordered Binary Decision Diagram."""
+
+from optivlsi.bdd.algorithms import evaluate_expression
+
+# Boolean expression: x & y
+# Truth table: 00->0, 01->0, 10->0, 11->1
+exp = "x & y"
+for x in [0, 1]:
+    for y in [0, 1]:
+        result = evaluate_expression({x, y}, exp)
+        print(f"x={x}, y={y} -> {exp} = {result}")
+
+print()
+
+# Another expression: (a & b) | c
+exp2 = "(a & b) | c"
+for a in [0, 1]:
+    for b in [0, 1]:
+        for c in [0, 1]:
+            result = evaluate_expression({a, b, c}, exp2)
+            print(f"a={a}, b={b}, c={c} -> {exp2} = {result}")

optivlsi-0.1.0/examples/bellman_ford_demo.py

@@ -0,0 +1,23 @@
+"""Example: Bellman-Ford shortest path algorithm."""
+
+import numpy as np
+from optivlsi.bellman_ford import bellman_ford, bellman_ford_networkx, bellman_ford_numba
+
+nodes = np.array([0, 1, 2, 3, 4], dtype=np.int64)
+edges = np.array([
+    [0, 1, 5],
+    [0, 2, 3],
+    [1, 3, 6],
+    [1, 2, 2],
+    [2, 4, 4],
+    [3, 4, 1],
+], dtype=np.int64)
+
+status, path = bellman_ford(nodes, edges, 0, 4)
+print(f"Pythonic result: status={status}, path={path}")
+
+status, path = bellman_ford_networkx(nodes, edges, 0, 4)
+print(f"NetworkX result: status={status}, path={path}")
+
+status, path = bellman_ford_numba(nodes, edges, 0, 4)
+print(f"Numba result: status={status}, path={path}")

optivlsi-0.1.0/examples/dijkstra_demo.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Example: Dijkstra shortest path on a directed graph."""
+
+import numpy as np
+from optivlsi.dijkstra import dijkstra, dijkstra_networkx
+
+# Small directed graph: 6 nodes, weighted edges
+nodes = np.array([0, 1, 2, 3, 4, 5], dtype=np.int64)
+edges = np.array([
+    [0, 1, 4],
+    [0, 2, 2],
+    [1, 3, 5],
+    [2, 3, 1],
+    [2, 4, 7],
+    [3, 5, 3],
+    [4, 5, 1],
+], dtype=np.int64)
+
+# Dijkstra from node 0 to node 5
+status, path = dijkstra(nodes, edges, 0, 5)
+print(f"Dijkstra path from 0 to 5: {path}")
+
+# Also try NetworkX variant
+status_nx, path_nx = dijkstra_networkx(nodes, edges, 0, 5)
+print(f"NetworkX Dijkstra path:  {path_nx}")
+print(f"Paths match: {path == path_nx}")

optivlsi-0.1.0/examples/kruskal_demo.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Example: Kruskal minimum spanning tree on an undirected graph."""
+
+import numpy as np
+from optivlsi.kruskal import kruskal, kruskal_networkx
+
+# Small undirected graph: 4 nodes
+nodes = np.array([0, 1, 2, 3], dtype=np.int64)
+edges = np.array([
+    [0, 1, 10],
+    [0, 2, 6],
+    [0, 3, 5],
+    [1, 3, 15],
+    [2, 3, 4],
+], dtype=np.int64)
+
+mst_edges, mst_weight = kruskal(nodes, edges)
+print(f"Kruskal MST edges: {mst_edges}")
+print(f"Kruskal MST weight: {mst_weight}")
+
+mst_edges_nx, mst_weight_nx = kruskal_networkx(nodes, edges)
+print(f"NetworkX MST weight: {mst_weight_nx}")
+print(f"Weights match: {mst_weight == mst_weight_nx}")

optivlsi-0.1.0/examples/lee_demo.py

@@ -0,0 +1,15 @@
+"""Example: Lee maze routing algorithm."""
+
+import numpy as np
+from optivlsi.lee import lee
+
+# Create a 5x5 maze with some obstacles
+maze = np.zeros((5, 5), dtype=np.int64)
+# Add some obstacles
+maze[1, 1] = 1
+maze[1, 2] = 1
+maze[2, 2] = 1
+maze[3, 2] = 1
+
+distance = lee(maze, 0, 0, 4, 4)
+print(f"Shortest path distance: {distance}")

optivlsi-0.1.0/examples/prim_demo.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Example: Prim minimum spanning tree on an undirected graph."""
+
+import numpy as np
+from optivlsi.prim import prim, prim_networkx
+
+# Small undirected graph: 4 nodes
+nodes = np.array([0, 1, 2, 3], dtype=np.int64)
+edges = np.array([
+    [0, 1, 10],
+    [0, 2, 6],
+    [0, 3, 5],
+    [1, 3, 15],
+    [2, 3, 4],
+], dtype=np.int64)
+
+mst_edges, mst_weight = prim(nodes, edges)
+print(f"Prim MST edges: {mst_edges}")
+print(f"Prim MST weight: {mst_weight}")
+
+mst_edges_nx, mst_weight_nx = prim_networkx(nodes, edges)
+print(f"NetworkX Prim weight: {mst_weight_nx}")
+print(f"Weights match: {mst_weight == mst_weight_nx}")

optivlsi-0.1.0/examples/simulation_demo.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Example: Digital circuit simulation using compiled-code simulator."""
+
+from optivlsi.simulation.compiled_code.simulator import (
+    generate_circuit, simulate
+)
+from itertools import product
+
+# Build a full adder circuit from benchmark file
+circuit_path = "compiled-code-simulator/benchmarks/fulladder.txt"
+circuit = generate_circuit(circuit_path)
+
+# Get input/output nodes
+from optivlsi.simulation.compiled_code.simulator import get_input_output_nodes
+inputs, outputs = get_input_output_nodes(circuit_path)
+
+print(f"Inputs: {inputs}, Outputs: {outputs}")
+
+# Simulate all input combinations
+for bits in product([0, 1], repeat=len(inputs)):
+    testvector = {inputs[i]: bits[i] for i in range(len(inputs))}
+    result = simulate(testvector, circuit)
+    print(f"Input {bits} -> Output {result}")

optivlsi-0.1.0/optivlsi/__init__.py

@@ -0,0 +1,10 @@
+"""
+optiVLSI - High-performance VLSI CAD algorithms with Numba-accelerated implementations.
+
+optiVLSI provides optimized implementations of VLSI CAD algorithms including graph algorithms
+(Bellman-Ford, Dijkstra, Kruskal, Prim), maze routing (Lee algorithm), digital circuit simulation
+(compiled-code and event-driven), and Reduced Ordered Binary Decision Diagrams (ROBDD).
+Each algorithm is available in Pythonic, NetworkX, and Numba-accelerated variants.
+"""
+
+__version__ = "0.1.0"

optivlsi-0.1.0/optivlsi/bdd/__init__.py

@@ -0,0 +1,67 @@
+"""
+Reduced Ordered Binary Decision Diagram (ROBDD) implementations.
+
+Provides:
+- build(): Build a BDD from a logical expression
+- evaluate(): Evaluate a BDD for given variable assignments
+- evaluate_numba(): Numba-accelerated evaluation
+"""
+
+import numpy as np
+
+from .algorithms import (
+    evaluate_expression,
+    evaluate_expression2 as _evaluate_expression_numba,
+    main as _build_bdd,
+    main_numba as _build_bdd_numba,
+    int_to_binary,
+)
+
+
+# Global state used by the original implementation
+order = ""
+inp = ""
+ord1 = None
+inp1 = None
+
+
+def build(expression, variable_order):
+    """Build a BDD from a logical expression.
+
+    Args:
+        expression: String logical expression (e.g., "a.b + ~a.b").
+        variable_order: String of variable ordering (e.g., "ab").
+
+    Returns:
+        BDD representation as a list.
+    """
+    global order, inp, ord1, inp1
+    order = variable_order
+    inp = expression
+
+    inp1_list = []
+    for ch in inp:
+        inp1_list.append(ord(ch))
+    inp1 = np.array(inp1_list, dtype=np.int32)
+
+    ord1_list = []
+    for ch in order:
+        ord1_list.append(ord(ch))
+    ord1 = np.array(ord1_list, dtype=np.int32)
+
+    # Set globals in the algorithms module directly
+    import optivlsi.bdd.algorithms as bdd_algo
+    bdd_algo.order = variable_order
+    bdd_algo.inp = expression
+    bdd_algo.ord1 = ord1
+    bdd_algo.inp1 = inp1
+
+    _build_bdd()
+    return _build_bdd_numba()
+
+
+__all__ = [
+    "build",
+    "evaluate_expression",
+    "int_to_binary",
+]