Merged docs with upstream dev
authorDmitriy Morozov <dmitriy@mrzv.org>
Thu, 15 Jul 2010 10:20:06 -0700
branchdev
changeset 214 ee0dca73ea47
parent 213 3568e0bfe2cd (diff)
parent 208 36ea2751f290 (current diff)
child 222 fdfde7291a0f
child 223 3d54247cbccf
Merged docs with upstream
--- a/doc/examples/index.rst	Tue Apr 20 13:58:23 2010 -0700
+++ b/doc/examples/index.rst	Thu Jul 15 10:20:06 2010 -0700
@@ -44,7 +44,7 @@
     cohomology
 
 A simple example of computing persistence of a lower-star filtration is in
-:sfile:`examples/lsfiltration.py`.
+:sfile:`examples/pl-functions/lsfiltration.py`.
 
 A C++-only, but useful example is computation of a vineyard of piecewise
 straight-line homotopy of piecewise-linear functions.
--- a/doc/get-build-install.rst	Tue Apr 20 13:58:23 2010 -0700
+++ b/doc/get-build-install.rst	Thu Jul 15 10:20:06 2010 -0700
@@ -37,19 +37,6 @@
   :Boost_:              C++ utilities (version :math:`\geq` 1.36; including Boost.Python used to create
                         Python bindings)
 
-.. warning::
-
-    There also seems to be a dependence on the version of GCC, although I don't
-    entirely understand it. GCC 4.3 and above definitely work, but some versions
-    below that seem not to.
-
-    One particular catch is that the default compiler on many current Mac OS X
-    is GCC 4.0 that has a well-known bug making Dionysus unusable. Fortunately
-    the problem is easy to solve by using GCC 4.2 that is often available on a
-    Mac under the name ``gcc-4.2``.
-
-    One can check the compiler version with ``g++ --version`` command.
-
 Optional dependencies:
 
   :CGAL_:               for alpha shapes and vineyards   (version :math:`\geq` 3.4)
--- a/doc/python/rips.rst	Tue Apr 20 13:58:23 2010 -0700
+++ b/doc/python/rips.rst	Thu Jul 15 10:20:06 2010 -0700
@@ -74,7 +74,7 @@
         def __len__(self):
             return len(self.points)
 
-        def __call__(self, x, y):
+        def __call__(self, p1, p2):
             return self.norm([x - y for (x,y) in zip(self.points[p1], self.points[p2])])
 
 Another distances class is available that speeds up the computation of the Rips
@@ -87,7 +87,7 @@
     distances = ExplicitDistances(distances)
 
 With :class:`PairwiseDistances` being a C++ class, and
-:class:`ExplicitDistances` being pure Python, the speead-up seems minor.
+:class:`ExplicitDistances` being pure Python, the speed-up seems minor.
 
 
 Example
--- a/doc/python/simplex.rst	Tue Apr 20 13:58:23 2010 -0700
+++ b/doc/python/simplex.rst	Thu Jul 15 10:20:06 2010 -0700
@@ -60,7 +60,7 @@
 
 The first function :func:`vertex_cmp` is a Python interface to a C++ function.
 The rest are pure Python functions defined in
-:sfile:`bindings/python/dionysis/__init__.py`.
+:sfile:`bindings/python/dionysus/__init__.py`.
 
 .. function:: vertex_cmp(s1, s2)
     
--- a/doc/tutorial.rst	Tue Apr 20 13:58:23 2010 -0700
+++ b/doc/tutorial.rst	Thu Jul 15 10:20:06 2010 -0700
@@ -55,7 +55,7 @@
 restricted to a :math:`k`-skeleton of the complex and some maximal parameter
 :math:`max`. In the following example :math:`k = 3` and :math:`max = 50`::
 
-    simplices = []
+    simplices = Filtration()
     rips.generate(3, 50, simplices.append)
 
 :meth:`Rips.generate` takes a skeleton and a maximum distance cutoffs, and a