Basic infrastructure code: Graph & node classes, along with some useful graph algorithms such as Dijkstra's, double sweep, etc...
DLL loading works! Created a dummy implementation for DDSweep (returns hard-coded values for now),which is run in main.
Created a separate lib project for the infrastructure code called "DeltaHyperbolicityToolkit". The DeltaHyperbolicity project is now simply an executable that uses the toolkit to load a graph and then loads an algorithm dll upon request and runs it on the graph.
Also implemented the DDSweep algorithm.
1. Bug fix with random value generation on DDSweep.
2. Some refactoring.
3. Running only the no-initial-state version from main.
4. Some project settings improved.
5. Added DSweep.
Added a nicer menu to the executable
1. Added brute force implementation.
2. Added the previously forgotten filters file for DSweep.
3. Added the AlgRunner wrapper for loading dlls & running algorithm implementations.
4. Improved documentation.
Changed algorithm interface such that input validity checks are performed in the base class.
1. Added the State class to support some state-related operations (e.g. assignment operator).
2. Finished the SA interface. Ready for implementations...
3. Updated missing project dependencies.
1. Algorithm runner doesn't load dll on ctor (so that we don't have to include it inside a try/catch, otherwise if it throws an exception the dll is unloaded before the exception is freed).
2. Improvements to the State class.
3. Improvements to the SA design.
4. Added an implementation for the SA.
1. Changed namespace from "graphs" to "dhtoolkit".
2. Added a helper method in IGraphAlg that runs the algorithm without a state and compares it to the given state (so that the runWithInitialState doesn't return a result that's worse than the original state, in cases where the algorithm doesn't consider the initial state).
3. Added a name property to the AlgRunner.
4. Plenty of changes in the main exe - can concatenate algorithms & load a folder of graphs. Also produce output csv's now.
5. Added a title property to Graph.
6. Added a "reset" method to the SA interfaces to allow reusing the same instance on multiple graphs.
7. Major bug fix in DSweep - delta value was calculated wrong.
1. Added a reset() method to the IGraphAlg interface, called every time the user calls run and runWithInitialState.
2. Added some helpful prints to std output when iterating a folder for graphs.
3. Bug fix - trying to load an invalid graph file now actually throws an exception (as opposed to freezing...).
Created files are now sharable for reading
Some code refactoring
Added a draw-graph method & algorithm (using Pajek).
1. Added notion of output dir - each algorithm receives an output dir into which it can write its outputs (if there are any, other than the delta hyperbolicity result - which it doesn't write itself).
2. File name in csv is truncated to including only the last 3 parent directories.
3. Added an SA callback method that is called on every step of the SA process. Currently used for drawing the current state's graph.
4. Using some helper boost libraries.
Haven't exactly been updating this repository....
Anyhow - this is the most up-to-date version. A bunch of algorithms, after majooor optimizations (using BFS, faster pruning with copy-and-swap instead of deletion, etc.).
Can now deal even with the largest graphs (millions of nodes & edges).
Haven't committed things in a *while*... Commit current state.
Reorganized DSweep algorithms:
1. Interface that performs the algorithm *except* for v3-candidate-choosing algorithm. Each derived class implements its own such algorithm.
2. Two derived classes:
2.a. DSweepMin remains as it was in terms of algorithm: Only "balanced" distances that are minimal (bug fixed: e.g. (5, 6) and (6, 5) are equally good). Difference from previous implementation: It received the cycle removal algorithm (inherited from the interface).
2.b. DSweepMinNonBalanced - Same as DSweepMin except v3's don't have to be with "balanced" distances from v1, v2.
3. Cycle removal algorithm is now a part of the toolkit (perhaps DDSweep and MDSweep should use it as well?).
Changed MDSweep such that it finds the double-sweep for the next step at the end of the previous step (instead of at the beginning of the new one). This way if we cannot find a new unique DS, we simply mark the algorithm as completed (instead of throwing an exception like before).

Also, increased the number of trials allowed to find a new DS from 50 to 500 (made a difference in some graphs).
1. Moved AlgRunner to toolkit.
2. A couple of bug fixes in Cohen.
3. Added a random number to file names based on time + process id.
4. Moved GraphBuilder implementation to toolkit.
5. Algorithm to remove cycles now returns (in an out parameter) the list of nodes processed, whether removed or were found to be non-removable.
6. Added toolkit support for loading files from an edge list (e.g. the format of most of the Stanford networks).