Added a note about reducing matrix Z in i/t/zigzag-persistence.hpp

Merge

Added store_negative argument to StaticPersistence.pair_simpices()

Added a note about wasserstein_distance() to documentation + cleaned up docs for init_diagrams()

Inlcuded munkres.cpp from munkres.h + matrix.cpp -> matrix.hpp

Added wasserstein_distance()

Exposed init_diagrams() to Python

Minor changes to compile with GCC 4.7

Added cohomology/candidates counter to i/t/cohomology-persistence.hpp

Minor fixes in tools/draw-diagram

alphashapes2d can handle degenerate inputs (thanks to Taras Galkovskyi for the bug report and the fix)

Fixed combinations in closure() for older versions of Python

closure() in Python can handle simplex data

Fixed a typo in b/p/persistence-diagram.cpp

Added a note about GPL to the documentation

Cleaned up CMake files to play nice with CGAL

Cleaned up PersistenceDiagram bindings

Fixed a link to SYNAPS

Merged in Python bindings for DynamicPersistenceChains

Added documentation for DynamicPersistenceChains

Added Python bindings for DynamicPersistenceChains

Added the ability to pickle Simplex class in Python

Added ability to iterate over ZigzagPersistence cycles in Python

Fixed a typo in the documentation of SPNode.cycle

Added Python closure function (for computing a k-skeleton of a closure of a list of simplices)

Removed the unnecessary typename in filtration-homology.cpp

Added output of essential cycles for any given input filtration

Minor touches in documentation

Merged docs with upstream

CGAL is unncessary for vineyards (update in the documentation)

Merged in Aravind's changes

Changed the first iterator of PersistenceDiagram to accept dimension as well. Modified documentation.

Removed the points iterator in PersistenceDaigram; replaced it with a __iter__ method. Got rid of some python code in __init__.py, since it was not needed with the above change. Changed the docs to reflect this.

Added documentation for the python classes Point and PersistenceDiagram. Removed the __sub__ method for PersistenceDiagram. Minor renaming. Renamed BottleneckDistance to bottleneck_distance. Renamed intervals iterator for PersistenceDiagram to points. Seems in better conformance with usage.

Added a __iter__ method to the PersistenceDiagram class in python. Renamed the points iterator to the intervals iterator.

Added extra functionality to Point class( an iterator ) and PersistenceDiagram( dimension property and __len__ func ). persistence-diagram.h: Added a new read-only dimension member and member function to access it. With a new constructor that that takes in an int type to initialize dimension. persistence-diagram.cpp: Added new bp::init constructor. Takes in an integer type to initialize the dimension. Exposed the dimension property. Exposed the size property via a __len__ method. __init__.py: Added an iterator for Point objects. This iterates over the coords and then the data( if present ).

Made the data argument in Point's __init__method to be an optional argument by making it a boost::python::optional.

Added code to expose the persistence_diagram class, the bottleneck_distance function and the point class to python. Most of the commonly used methods for each class have been exported. The constructor for point now requires that a data argument be provided along with x and y coord. This needs to be made optional. The constructor for persistence_diagram could possibly be rewritten as well.

Merged docs with upstream

Removed the warning about compiler versions (seems unnecessary after Andrew's fixes)

Fixed path for lsfiltration.py

Bug in the tutorial: simplices = [] -> simplices = Filtration()

More typos in the docs

Fixed a link: dionysis -> dionysus

Andrew Yarmola's fix to the in-class intialization syntax in OrderList<T>

Added Persistence::initialize(f) + fixed minor bug LinearKernel::sign_at_negative_infinity()

Added insert-at-the-end optimization for CohomologyPersistence::add_cocycle()

Count cocycles in CohomologyPersistence

Andrew Yarmola's compilation fix for MacOSX.

Removed unused instrumentation of cohomology and unnecessary includes

Removed reference to reference in ThreeOutcomeComparison

Made EventQueue into a binary heap (for efficiency and sanity)

Replaced list with multi_index representation in EventQueue making it more efficient

Switched to internal KineticSort

Added linear kernel for my own KineticSort

Commented out QField to get rid of the artifical dependence on GMP

Fixed non-copyable temporary bug

Fixed the duplicates (degeneracy) and another assertion problem in LSVineyard

Removed a buggy assertion in LSVineard::transpose_vertices() (j points at the end() when moving the last simplex of the filtration)

StaticPersistence::pair_simplices() has an option to not display progress (LSVineyard uses it during consistency checking)

Added rips-explicit-cohomology

Moved lsfiltration.py into examples/pl-functions + added lscubes.py example (cubical lower-star filtration)

Fixed Python constructor of CohomologyPersistence + minor changes to cocycle.py

vertex_coface -> vertex_cofaces in Rips documentation (in Python)

Henry Adams' fixes to python/dionysus/zigzag.py + added CohomologyPersistence.show_cocycles method

CohomologyPersistence::add returns the dying cocycle

Check Boost version in include/utilities/property-maps.h + minor changes to cocycle.py

Added pl-vineyard documentation

Fixed a serious bug in DynamicPersistenceTrails + LSVineyard sorts filtration by attachment + miscellanea: * added program options to pdbdistance-vineyard * pdbdistance-vineyard takes frame list in a file * more logging * verification of pairing after vertex transpositions (commented out)

Moved files around: lsvineyard.h -> include/topology, examples/grid -> examples/pl-functions

Merged Vineyards code changes with the main development line

Python bindings work again

Created pl-vineyard.cpp to compute vineyards given a complex and a sequence of values at each vertex

Resurrected vineyard code: * Switched StaticPersistence + (serializable) Filtration to Boost.MultiIndex * Updated DynamicPersistenceTrails to work with the new MultiIndex way * Created LSVineyard class, and fixed the grid examples

Made storing negative simplices in StaticPersistence parameter-based, so that DynamicPersistence works again

StaticPersistence operates on chains consisting of only positive simplices

alphashapes3d.cpp measures persistence time

Fixed DynamicPersistenceTrails::PairingTrailsVisitor to match the changes in StaticPersistence::PairVisitor

Instrumented code for counting: * added counters to addition in cohomology and ChainWrapper * rips-pairwise-cohomology counts the maximum elements stored in the cycles * added alphashapes3d-cohomology * moved progress_display from DynamicPersistence to StaticPersistence

Added arbitrary coefficients in boundaries (to C++ and Python) + cleaned up CohomologyPersistence.add overloading in Python

Added image persistence functionality to CohomologyPersistence

Added draw.py under tools/draw-diagram

Added link to CVXOPT in get-build-install documentation + progress bar to rips-pairwise-cohomology

Fixed a typo in documentation + added a warning and a tip about GCC 4.2 on a Mac

The if-else cases in lsqr.py were not exhaustive. They become exhaustive by changing ab > aa to ab >= aa.

Removed Qt4 requirement + added link to download and tutorial to the front page of the documentation

Exposed store argument to CohomologyPersistence.add() in Python

cocycle.py uses vertex list, and does not make any assumptions about the vertex-simplex order

Consistency zigzag outputs intervals supported over a single complex

explicitely converts a Dimension (short int) into a size_t, for removing a warning

Removing unused parameter names in order to avoid warnings -> no warning anymore in zigzag-persistence

make-zigzag-subsamples.py doesn't output the union, rips-consistency-zigzag.cpp fixed show_progress

Fixed bugs in cocycle.py introduced when rips-pairwise-cohomology.py was originally added

Fixed bugs in rips-pairwise-cohomology.py whose origin is unclear to me

Merged in Chris' changes

Modified cohomology code (unweighted and weighted) so that it doesn't use std::map for boundary computations, which should optimize memory usage.

Changed implementation of WeightedRips to store simplex values (max distance between simplices' vertices) as an invisible layer on top of each simplex object, so that the data() field of WeightedRips has been freed for use by the users again.

Added rips-weighted-cohomology, and channeled WeightedRips logging to the same channel as Rips

Merged upstream

Modified WeightedRips::generate() to incorporate the simplex-appearance-value computation (before it would have to be done explicitly by the user by a for-loop after the call to generate())

added logging to WeightedRips (still needs debugging)

Updated weighted rips libraries to make use of OOP--now WeightedRips inherits from Rips. It is possible that logging for WeightedRips does not work.

Added weighted rips code and libraries

Simplices are deleted from the complex after removal in triangle-zigzag.py + touched up documentation (to mention CohomologyPersistence better)

Consistency zigzag outputs intervals for dimensions less than the skeleton dimension only

Switched PairwiseDistances in Python bindings to C++

Added Python bindings for CohomologyPersistence (+ example + documentation)

Minor changes in distances.py + rips-pairwise.py wrapped into a main() function

Disable alphashapes in Python bindings if no CGAL

Made ListRandomAccessIterator generic with respect to value, and moved it to utils.h

Cleaner output in rips-pairwise.cpp + added make-zigzag-subsamples.py + added lsfiltration.py

Fixed plot.py in tools/plot-values

In documentation put contents into sidebar

Documentation for parametrization using persistent cohomology

Rips pairwise cohomology produces output necessary for 1-cocycle parametrization

Added field arithmetic to CohomologyPersistence (Zp + Q)

Moved PairwiseDistances and ExplicitDistances into include/geometry/distances.h

read_points() does not need ambient dimension and ignores lines starting with '#'

Added documentation; for now mostly for the Python bindings

Touch up to compile with GCC 4.4

Cleaned up simplex comparison functions, rip-pairwise.py outputs a diagram, auxilliary add_simplices() + remove_simplices() for zigzags

Alphashapes and Python bindings * converted alphashapes2d to the new format * added Python bindings for alphashapes * added sample alphashapes.py that dynamically distinguishes between 2D and 3D

Placed all Python bindings code into dionysus::python namespace

Cleaned up Python bindings to restore functionality: * StaticPersistence is iterable, its nodes are usable (sign, pair, cycle) * StaticPersistence knows how to map its nodes into Filtration indices * moved PythonCmp into utils.h * minor cosmetic changes

Renamed header files in bindings/python to get rid of the "python-" prefix

Changes in Python Bindings: * the exposed C++ simplex has Empty data * Python Simplex constructor with data as well as data-based comparison functions are implemented in pure Python

Added Python bindings for the Rips complex + an example

Cleaned up traits (chain and container) for static- and dynamic-persistence

Added tools/extract-diagram + minor fixes

Added intrusive containers issue and issue filters

Moved l2distance.h into include/geometry

Added categories to some of the issues

Fixed distance to diagonal calculation + added stand-alone bottleneck distance tool

Added ZigzagPersistence::is_alive() + consistency zigzag outputs betti 1 at each stage

Added consistency zigzag

Merged in cohomology branch

Added CohomologyPersistence and Rips pairwise distances computation

Added DynamicPersistenceChains (no dynamic part yet)

Updated Rips zigzags * Updated to use Bron-Kerbosch * Compute in the order of increasing epsilon, and decreasing point sizes * Split into plain zigzag (rips-zigzag) and image zigzag (rips-image-zigzag) * Added minor enhancements (show_progress and timers)

Switched Rips complex computation to Bron-Kerbosch algorithm

Added python bindings for ZigzagPersistence (as well as ImageZigzagPersistence)

Switched to CGAL 3.4 (native CMake configuration): for now only alphashapes

Implemented ImageZigzagPersistence * Changed ZigzagPersistence to support a visitor, and implemented ImageZigzagPersistence * examples/rips/rips-zigzag now computes using ImageZigzagPersistence * PersistenceDiagram no longer records zero persistence pairs * Added utilities/memory.h with report_memory() function

Debugged ZigzagPersistence (having added heavier consistency checking) * Added DEBUG_CONTAINERS option (uses std::__debug::* containers for chains and in ZigzagPersistence) * Added SizeStorage specialization for std::deque<T> * ZigzagPersistence got a lot more consistency checking (in debug mode only, which now crawls); as a result it's been debugged (running on non-trivial examples) * examples/rips/rips-zigzag takes command-line options * added ChainWrapper::clear() * added Simplex::VertexDimensionComparison * added PairwiseDistances class (for computing distances between points in a container according to a distance functor)

Added rips-zigzag; in the process caught a number of bugs in ZigzagPersistence (added check_consistency() to it)

Added DequeChains (for ZigzagPersistence)

Added ZigzagPersistence

Merged in Python branch

Initial commit of Python bindings

Empty is now a template, replaced RecursiveIterator with boost::counting_iterator

Removed boundary() from AlphaSimplex3D

Changed Simplex::boundary() to be iterator-based (replaced it with boundary_begin() and boundary_end())

Commit before merging in Python branch: * converted more examples: poincare, rips, some fitness * two generators for Rips complexes * ChainWrapper uses stl algorithms for everything, added CountingBackInserter and switched SizeStorage to use operators * retabbing files along the way * added #957a (namespace dionysus)

Initial addition of tools/diagram-viewer

Closed #8a1 and #96b, added #de6 and #f64

Intermediate commit while converting to the new architecture * Converted Filtration into StaticPersistence and DynamicPersistenceTrails (both right now work with the underlying std::vector rather than std::list order) * Filtration is now just an auxilliary glue (a map between Complex and Persistence) * Whether chains are vectors or lists can be interchanged * Added PersistenceDiagram with a simple bottleneck_distance() function * Converted triangle, alphashapes3d, and cech-complex examples * Lots of organizational changes (factoring utilities out into containers.h, indirect.h, property-maps.h) * Trying to document along the way with NaturalDocs-type comments

Switching README to PanDoc

Added Rips complex-based distance computation to fitness

Added ExplicitDistance + Evaluator to Rips complexes

Merged in Rips complexes

Added initial code for Rips complexes

Added join() operation for a Simplex

Removed inclusion of seemingly unnecessary boost/serialization/is_abstract.hpp header

Converted issues to Maildir format, added Boost 1.36 issue

Added cmake_minimum_required for compatibility with CMake 2.6

Merge in AR branch

Fixed #c42 for ar-vineyard

Merged in upstream changes and reopened #c42

KineticEvaluator takes the maximum time between the two simulators

Small logging additions + maintain_lazy = false + eventqueue - Filtration::transpose( ..., maintain_lazy = false ) - EventQueue inserts a new event after all the ones equal to it, not before

Marked #c66 and #d2a as fixed (fixes in f236c7d659d0 and abba2950aced, respectively)

Fixed Vineyard to preserve the vine addresses after we add a new dimension vine (was a major bug)

Using two simulators in ARVineyard (one for simplices and one for trajectories) - Fixes #c66 - Simulator::reached_infinity() examines the queue instead of keeping state in a variable

ConeSimplex and ARConeSimplex3D adjusted to work correctly with operator<(), operator==(), and boundary()

ConeSimplex correctly reports dimension()

program_options + trajectory knees - added boost::program_options - recording knees when trajectories change

Merged upstream changes (to get boost::program_options setup in CMake)

Merged in fitness branch

ar-vinyeard compiles and runs: - ar-function-kernel uses int for sign rather than bool in sign_at - switched to dealing with a single functions themselves in value_at - order of thresholds is handled correctly in ar-vineyard (max is the last one)

Added intostring() issue (#89a)

KineticSort can deal with equal trajectories: UPolynomial::sign_at_negative_infinity() can handle 0 and so can Simulator::add()

Fixed UPolynomial<T>::sign_at_negative_infinity() + Simulator::add() Bug in the former and resulting logic problems in the latter.

Added and fixed CGAL debugging problem (issue #c42)

Added EventQueue efficiency issue (#ebd)

Initial commit of KineticSort-based ARVineyard Compiles, but needs to be runtime debugged.

Issue #cd7: incorrect UPolynomial<double>::sign_at()

Fixed Simulator not processing events correctly Event that is being processed needed to be removed from the queue while its own process() method ran.

Fixed segfault in test-kinetic-sort (#b5d)

Added segfault in test-kinetic-sort issue

Changed PolynomialKernel to FunctionKernel

Changed geometry to RLog-based logging and counters

Added class groups to Doxygen documentation

Merged in changes from master

Commit to merge in changes from master.

Fixed handling of degeneracies in KineticSort, Simulator is aware of the sign of the RationalFunction

Merged CGAL 3.3 changes with the work on ARVineyard

Work in progress on ARVineyard and KineticSort. Commit to merge in CGAL 3.3 changes.

tests/geometry now match the include/ breakup and are switched to CMake

Fixed the mislabeled Case 1.2

Added Poincare sphere example