author Dmitriy Morozov Tue, 05 Jun 2012 14:50:58 -0700 branch dev changeset 256 0f632dc3f53b parent 255 a7e010314a03 child 257 d69a9e11205e
Added docs for StaticCohomologyPersistence + ImagePersistence + circular.smooth + minor fixes in adaptor.py
--- a/bindings/python/dionysus/__init__.py	Mon Jun 04 09:05:45 2012 -0700
+++ b/bindings/python/dionysus/__init__.py	Tue Jun 05 14:50:58 2012 -0700
@@ -2,8 +2,7 @@
from    distances   import l2, ExplicitDistances, points_file
from    zigzag      import *
-from    circular    import smooth
-
+import  circular

def init_with_none(self, iter, data = None):        # convenience: data defaults to None
self._cpp_init_(iter, data)
--- a/bindings/python/dionysus/adaptor.py	Mon Jun 04 09:05:45 2012 -0700
+++ b/bindings/python/dionysus/adaptor.py	Tue Jun 05 14:50:58 2012 -0700
@@ -23,6 +23,11 @@
cocycle = self.persistence.__iter__().next()
self.pairs[-1][2] = [(n.coefficient, n.si.order) for n in cocycle]

+    def __call__(self, n):
+        return n.i
+
+    def __len__(self):
+        return len(self.pairs)

def __iter__(self):
for i, (pair, subcomplex, cocycle) in enumerate(self.pairs):
@@ -69,6 +74,7 @@
def pair(self):
return APNode(self._pair(), self.pairs)

+    @property
def cocycle(self):
return self.pairs[self.i][2]

--- a/doc/python/cohomology-persistence.rst	Mon Jun 04 09:05:45 2012 -0700
+++ b/doc/python/cohomology-persistence.rst	Tue Jun 05 14:50:58 2012 -0700
@@ -12,18 +12,18 @@
coming from :math:\mathbb{Z}/prime \mathbb{Z}.

.. method:: add(boundary, birth, [store = True], [image = True], [coefficients = []])
-
-        Adds a simplex with the given boundary to the complex, i.e.
+
+        Adds a simplex with the given boundary to the complex, i.e.
:math:K_{i+1} = K_i \cup \sigma and boundary = :math:\partial \sigma.
-        If a new class is born as a result of the addition, birth is stored with
-        it for future reference.
-
+        If a new class is born as a result of the addition, birth is stored with
+        it for future reference.
+
If store is False and a class is born, it will not be stored in
:class:CohomologyPersistence. This is useful to not waste space on the
classes of the dimension equal to the maximum-dimensional simplices of
the complex since such classes will never die.

-        The image parameter allows one to work with a case of a space
+        The image parameter allows one to work with a case of a space
:math:L \subseteq K where the filtration of :math:K induces a
filtration of :math:L. In this case, one may want to compute **image
persistence** (i.e. the persistence of the sequences of the images given
@@ -34,7 +34,7 @@
coefficients for the corresponding boundary elements. If empty, it is
assumed to be :math:(-1)^i.

-        :returns: a pair (i, d). The first element is the index i.
+        :returns: a pair (i, d). The first element is the index i.
It is the internal representation of the newly added simplex,
and should be used later for removal or when constructing the
boundaries of its cofaces. In other words, boundary must
@@ -50,8 +50,8 @@
:class:CohomologyPersistence. The returned elements are of the type
:class:Cocycle below.

-
-.. class:: Cocycle
+
+.. class:: Cocycle

.. attribute:: birth

@@ -82,3 +82,91 @@

The count associated with the simplex when it is inserted into
:class:CohomologyPersistence.
+
+
+-------
+
+:class:StaticCohomologyPersistence provides a wrapper around
+class :class:CohomologyPersistence that's compatible with :class:StaticPersistence.
+See the documentation of the latter class for details.
+
+
+.. class:: StaticCohomologyPersistence
+
+   .. method:: __init__(filtration, prime = 2)
+
+        Initializes :class:StaticCohomologyPersistence with the given
+        :class:Filtration. prime is passed straight to the wrapped
+        :class:CohomologyPersistence class.
+
+   .. method:: pair_simplices()
+
+        Pairs simplices using :class:CohomologyPersistence class.
+
+   .. method:: __call__(i)
+
+        Given a node in the internal representation, the method returns its
+        integer offset from the beginning of the filtration.
+
+   .. method:: make_simplex_map(filtration)
+
+        Creates an auxilliary map from the nodes to the simplices::
+
+            smap = persistence.make_simplex_map(filtration)
+            for i in persistence:
+                if i.unpaired(): print smap[i]
+
+   .. method:: __iter__()
+
+        Iterator over the nodes (representing individual simplices). See
+        :class:APNode.
+
+   .. method:: __len__()
+
+        Returns the number of nodes (i.e. the number of simplices).
+
+.. class:: APNode
+
+    The following methods behave the same way as they do in :class:SPNode.
+
+    .. method:: sign()
+
+    .. method:: pair()
+
+    .. method:: unpaired()
+
+    The only crucial distinction in the behavior comes with the attribute
+    :attr:cocycle.
+
+    .. attribute:: cocycle
+
+        If the simplex is positive, this attribute stores a cocycle it created.
+        The 1-dimensional cocycles can be used with the :func:circular.smooth function to turn
+        them into circle-valued maps.
+        ::
+
+            for i in persistence:
+                if i.sign(): print i.cocycle
+
+
+.. class:: ImagePersistence
+
+    This class is another wrapper around :class:CohomologyPersistence that can
+    compute image persistence induced by inclusion of a subcomplex. Its
+    interface is the same as :class:StaticCohomologyPersistence above, except
+    for the constructor:
+
+    .. method:: __init__(filtration, subcomplex)
+
+       subcomplex is a function called with every simplex. It should return
+       True if the simplex belong to the subcomplex; False otherwise.
+
+
+Circular coordinates
+--------------------
+
+.. function:: circular.smooth(filtration, cocycle)
+
+   Returns a map from the vertices of the simplicial complex filtration to a circle :math:[-.5, .5],
+   where the opposite ends of the interval are identified.