Metadata-Version: 2.1
Name: fastpath
Version: 1.7
Summary: A package for finding the best path through a network graph
Home-page: https://github.com/deprekate/fastpath
Author: Katelyn McNair
Author-email: deprekate@gmail.com
License: UNKNOWN
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
Classifier: Operating System :: OS Independent
Requires-Python: >3.5.2
Description-Content-Type: text/markdown
License-File: LICENSE

Introduction
------------

Fastpath is a fast and lightweight tool for finding the shortest path in a weighted
graph.  As input it only needs the starting node, the ending node, and the weights
of each node to node edge.  For versatility it uses the Bellman-Ford algorithm, which
allows for negative weights.  Future version will incorporate the Dijkstra algorithm
to speed up runtimes on graphs that do not contain negative edges.
To install `fastpath`,
```sh
git clone git@github.com:deprekate/fastpath.git
cd fastpath; make
```
The only library dependency for fastpath is uthash (which is included).
The fastpathz has the extra dependency of mini-gmp (which is included).

There are two flavors of `fastpath`.  The first is the default `fastpath`, which will work
for 99% of needed cases.  It's limitation is that it uses the C-type long double for edge
weights, which can cause rounding errors if you have extremely large/small numbers for edge
weights (ie -1E50 or 1E50).
This is because during the path relaxation step of the Bellmanford code, C cannot distinguish
a difference between 1E50 and 1E50 + 1
If your numbers are extremely large/small, then you can use the `fastpathz` version, which
uses infinite-precision integers as edge weights. The downside of using `fastpathz` is that
decimal places get dropped, so the C code does not distinguish between 1 and 1.1.  This 
limitation can partially be overcome by just multiplying all your weights by an arbitrary
number.



Fastpath Example
--------------

Run either flavor on the included sample data:
```sh
fastpath --source A --target Z < edges.txt 
```
```sh
fastpathz --source A --target Z < edges.txt 
```
The output of either command is the path of nodes, and should look like
```sh
A
B
D
E
Z
```

The structure of the graph looks like:

```sh
A -----> B -----> C <----- F
         |        |
         |        |
         v        v
         D -----> E -----> Z
```

* Strings can be used for the nodes, and the weights can be positive or negative long double 
  numbers. The weights can even be in the form of scientific shorthand (1.6E+9).


Python Example
--------------

FastPath is now also available as a PIP package available at [pypi.org](https://pypi.org/project/fastpath/)

It is installable by simply using pip
```sh
pip install fastpath 
```

To use in your python code, first import the module, write edges to the graph, and then provide a beginning node (source) and an end node (target)
```sh
import fastpath as fp

f = open("edges.txt", "r")
for line in f:
        ret = fp.add_edge(line)

for edge in fp.get_path(source="A", target="Z"):
        print(edge)
```

Output is the path of nodes, and should look like
```sh
$ python example.py 
A
B
D
E
Z
```


