shapely 1.2.13__py2.7-win-amd64.egg → 1.2.18__py2.7-win-amd64.egg

shapely/tests/Array.txt

@@ -0,0 +1,86 @@
+Test implementation of array interface
+======================================
+
+  >>> from shapely.geometry import Point
+
+  >>> p = Point(0.0, 0.0, 1.0)
+  >>> coords = p.coords[0]
+  >>> coords
+  (0.0, 0.0, 1.0)
+  >>> p.ctypes #doctest: +ELLIPSIS
+  <shapely.geometry.point.c_double_Array_3 object at ...>
+
+  Convert to Numpy array, passing through Python sequence
+
+  >>> from numpy import asarray
+  >>> a = asarray(coords)
+  >>> a.ndim
+  1
+  >>> a.size
+  3
+  >>> a.shape
+  (3,)
+
+  Convert to Numpy array, passing through a ctypes array
+
+  >>> b = asarray(p)
+  >>> b.size
+  3
+  >>> b.shape
+  (3,)
+  >>> b[0]
+  0.0
+  >>> b[1]
+  0.0
+  >>> b[2]
+  1.0
+
+  Make a point from a Numpy array
+
+  >>> a = asarray([1.0, 1.0, 0.0])
+  >>> p = Point(*list(a))
+  >>> p.wkt
+  'POINT (1.0000000000000000 1.0000000000000000)'
+
+LineString
+----------
+
+  >>> a = asarray([[0.0, 0.0], [2.0, 2.0], [1.0, 1.0]])
+  >>> from shapely.geometry import LineString
+  >>> line = LineString(a)
+  >>> line.wkt
+  'LINESTRING (0.0000000000000000 0.0000000000000000, 2.0000000000000000 2.0000000000000000, 1.0000000000000000 1.0000000000000000)'
+
+  >>> data = line.ctypes
+  >>> data[0]
+  0.0
+  >>> data[5]
+  1.0
+
+  >>> b = asarray(line)
+  >>> b.shape
+  (3, 2)
+  >>> b
+  array([[ 0.,  0.],
+         [ 2.,  2.],
+         [ 1.,  1.]])
+
+Polygon
+-------
+
+  >>> a = asarray(((0., 0.), (0., 1.), (1., 1.), (1., 0.), (0., 0.)))
+  >>> from shapely.geometry import Polygon
+  >>> polygon = Polygon(a)
+  >>> polygon.wkt
+  'POLYGON ((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000))'
+
+  >>> b = asarray(polygon.exterior)
+  >>> b.shape
+  (5, 2)
+  >>> b
+  array([[ 0.,  0.],
+         [ 0.,  1.],
+         [ 1.,  1.],
+         [ 1.,  0.],
+         [ 0.,  0.]])
+

shapely/tests/GeoInterface.txt

@@ -0,0 +1,69 @@
+Test implementation of geo interface
+====================================
+
+  >>> from shapely.geometry import asShape
+
+  Adapt a dictionary
+
+  >>> d = {"type": "Point", "coordinates": (0.0, 0.0)}
+  >>> shape = asShape(d)
+  >>> shape.geom_type
+  'Point'
+  >>> tuple(shape.coords)
+  ((0.0, 0.0),)
+
+  Adapt an object that implements the geo protocol
+
+  >>> class GeoThing(object):
+  ...     def __init__(self, d):
+  ...         self.__geo_interface__ = d
+
+  >>> shape = None
+  >>> thing = GeoThing({"type": "Point", "coordinates": (0.0, 0.0)})
+  >>> shape = asShape(thing)
+  >>> shape.geom_type
+  'Point'
+  >>> tuple(shape.coords)
+  ((0.0, 0.0),)
+
+  Check line string
+
+  >>> shape = asShape({'type': 'LineString', 'coordinates': ((-1.0, -1.0), (1.0, 1.0))})
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.linestring.LineStringAdapter object at ...>
+  >>> tuple(shape.coords)
+  ((-1.0, -1.0), (1.0, 1.0))
+
+  polygon
+
+  >>> shape = asShape({'type': 'Polygon', 'coordinates': (((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0), (0.0, 0.0)), ((0.10000000000000001, 0.10000000000000001), (0.10000000000000001, 0.20000000000000001), (0.20000000000000001, 0.20000000000000001), (0.20000000000000001, 0.10000000000000001), (0.10000000000000001, 0.10000000000000001)))})
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.polygon.PolygonAdapter object at ...>
+  >>> tuple(shape.exterior.coords)
+  ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0), (0.0, 0.0))
+  >>> len(shape.interiors)
+  1
+
+  multi point
+  >>> shape = asShape({'type': 'MultiPoint', 'coordinates': ((1.0, 2.0), (3.0, 4.0))})
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.multipoint.MultiPointAdapter object at ...>
+  >>> len(shape.geoms)
+  2
+
+  multi line string
+
+  >>> shape = asShape({'type': 'MultiLineString', 'coordinates': (((0.0, 0.0), (1.0, 2.0)),)})
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.multilinestring.MultiLineStringAdapter object at ...>
+  >>> len(shape.geoms)
+  1
+
+  multi polygon
+
+  >>> shape = asShape({'type': 'MultiPolygon', 'coordinates': [(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)), ((0.10000000000000001, 0.10000000000000001), (0.10000000000000001, 0.20000000000000001), (0.20000000000000001, 0.20000000000000001), (0.20000000000000001, 0.10000000000000001), (0.10000000000000001, 0.10000000000000001)))]})
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.multipolygon.MultiPolygonAdapter object at ...>
+  >>> len(shape.geoms)
+  1
+

shapely/tests/IterOps.txt

@@ -0,0 +1,31 @@
+Test operator iterations
+========================
+
+  >>> from shapely.geometry import Polygon
+  >>> from shapely.geometry import Point
+  >>> coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0))
+  >>> polygon = Polygon(coords)
+  >>> points = [Point(0.5, 0.5), Point(2.0, 2.0)]
+  
+  >>> from shapely import iterops
+  
+  List of the points contained by the polygon
+  >>> list(iterops.contains(polygon, points, True)) # doctest: +ELLIPSIS
+  [<shapely.geometry.point.Point object at ...>]
+
+  'True' is the default value
+  >>> list(iterops.contains(polygon, points)) # doctest: +ELLIPSIS
+  [<shapely.geometry.point.Point object at ...>]
+
+  Test a false value
+  >>> list(iterops.contains(polygon, points, False)) # doctest: +ELLIPSIS
+  [<shapely.geometry.point.Point object at ...>]
+
+  If the provided iterator yields tuples, the second value will be yielded
+  >>> list(iterops.contains(polygon, [(p, p.wkt) for p in points], False))
+  ['POINT (2.0000000000000000 2.0000000000000000)']
+
+  Just to demonstrate that the important thing is that the second parameter
+  is an iterator:
+  >>> list(iterops.contains(polygon, iter((p, p.wkt) for p in points)))
+  ['POINT (0.5000000000000000 0.5000000000000000)']

shapely/tests/LineString.txt

@@ -0,0 +1,134 @@
+LineStrings
+===========
+
+Initialization
+--------------
+
+    >>> from shapely.geometry import LineString
+
+Construct from a numpy array
+
+    >>> from numpy import array
+    >>> line = LineString(array([[0.0, 0.0], [1.0, 2.0]]))
+    >>> len(line.coords)
+    2
+    >>> line.wkt
+    'LINESTRING (0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000)'
+
+From coordinate tuples
+
+    >>> line = LineString(((1.0, 2.0), (3.0, 4.0)))
+    >>> len(line.coords)
+    2
+    >>> line.wkt
+    'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+From lines
+
+    >>> copy = LineString(line)
+    >>> len(copy.coords)
+    2
+    >>> print copy.wkt
+    LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)
+
+
+Numpy Support
+-------------
+
+    >>> from numpy import asarray
+    >>> la = asarray(line)
+    >>> la
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+    >>> la[0]
+    array([ 1.,  2.])
+
+Coordinate sequences can be adapted as well
+
+    >>> asarray(line.coords)
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+Bounds
+------
+
+    >>> line.bounds
+    (1.0, 2.0, 3.0, 4.0)
+
+Coordinate Access
+-----------------
+
+    >>> tuple(line.coords)
+    ((1.0, 2.0), (3.0, 4.0))
+
+    >>> line.coords[0]
+    (1.0, 2.0)
+    >>> line.coords[1]
+    (3.0, 4.0)
+    >>> line.coords[2]
+    Traceback (most recent call last):
+    ...
+    IndexError: index out of range
+
+Geo interface
+-------------
+
+    >>> line.__geo_interface__
+    {'type': 'LineString', 'coordinates': ((1.0, 2.0), (3.0, 4.0))}
+
+
+Coordinate modification
+-----------------------
+
+    >>> line.coords = ((-1.0, -1.0), (1.0, 1.0))
+    >>> line.__geo_interface__
+    {'type': 'LineString', 'coordinates': ((-1.0, -1.0), (1.0, 1.0))}
+
+
+Adapter
+-------
+
+    >>> from shapely.geometry import asLineString
+
+    Adapt a Numpy array to a line string
+
+    >>> a = array([[1.0, 2.0], [3.0, 4.0]])
+    >>> la = asLineString(a)
+    >>> la.context
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+    >>> la.wkt
+    'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+Now, the inverse
+
+    >>> la.__array_interface__ == la.context.__array_interface__
+    True
+    >>> pas = asarray(la)
+    >>> pas
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+Adapt a coordinate list to a line string
+
+    >>> coords = [[5.0, 6.0], [7.0, 8.0]]
+    >>> la = asLineString(coords)
+    >>> la.wkt
+    'LINESTRING (5.0000000000000000 6.0000000000000000, 7.0000000000000000 8.0000000000000000)'
+
+Test Non-operability of Null geometry
+
+    >>> l_null = LineString()
+    >>> l_null.wkt # doctest: +ELLIPSIS
+    'GEOMETRYCOLLECTION EMPTY'
+
+    >>> l_null.length # doctest: +ELLIPSIS
+    0.0
+
+Check that we can set coordinates of a null geometry
+
+    >>> l_null.coords = [(0, 0), (1, 1)]
+    >>> print l_null.length # doctest: +ELLIPSIS
+    1.414...
+

shapely/tests/MultiLineString.txt

@@ -0,0 +1,81 @@
+MultiLineStrings
+================
+
+Initialization
+--------------
+
+  >>> from shapely.geometry import LineString, MultiLineString
+
+From coordinate tuples
+
+  >>> geom = MultiLineString( (((1.0, 2.0), (3.0, 4.0)),) )
+  >>> geom # doctest: +ELLIPSIS
+  <shapely.geometry.multilinestring.MultiLineString object at ...>
+  >>> len(geom.geoms)
+  1
+  >>> geom.wkt
+  'MULTILINESTRING ((1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000))'
+
+Construct from a numpy array
+
+  >>> from numpy import array
+  >>> geom = MultiLineString( [array(((0.0, 0.0), (1.0, 2.0)))] )
+  >>> geom # doctest: +ELLIPSIS
+  <shapely.geometry.multilinestring.MultiLineString object at ...>
+  >>> len(geom.geoms)
+  1
+  >>> geom.wkt
+  'MULTILINESTRING ((0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000))'
+
+From lines
+
+  >>> a = LineString(((1.0, 2.0), (3.0, 4.0)))
+  >>> ml = MultiLineString([a])
+  >>> len(ml.geoms)
+  1
+  >>> print ml.wkt
+  MULTILINESTRING ((1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000))
+
+From another multi-line
+
+  >>> ml2 = MultiLineString(ml)
+  >>> len(ml2.geoms)
+  1
+  >>> print ml2.wkt
+  MULTILINESTRING ((1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000))
+
+
+Sub-geometry Access
+-------------------
+
+  >>> geom.geoms[0] # doctest: +ELLIPSIS
+  <shapely.geometry.linestring.LineString object at ...>
+  >>> geom.geoms[0].wkt
+  'LINESTRING (0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000)'
+  >>> geom.geoms[1]
+  Traceback (most recent call last):
+  ...
+  IndexError: index out of range
+
+Geo interface
+-------------
+
+  >>> geom.__geo_interface__
+  {'type': 'MultiLineString', 'coordinates': (((0.0, 0.0), (1.0, 2.0)),)}
+
+Adapter
+-------
+
+  >>> from shapely.geometry import asMultiLineString
+
+  Adapt a sequence of Numpy arrays to a multilinestring
+
+  >>> a = [ array(((1.0, 2.0), (3.0, 4.0))) ]
+  >>> geoma = asMultiLineString(a)
+  >>> geoma.context
+  [array([[ 1.,  2.],
+         [ 3.,  4.]])]
+
+  >>> geoma.wkt
+  'MULTILINESTRING ((1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000))'
+

shapely/tests/MultiPoint.txt

@@ -0,0 +1,101 @@
+MultiPoints
+===========
+
+Initialization
+--------------
+
+  >>> from shapely.geometry import Point, MultiPoint
+
+Construct from a numpy array
+
+  >>> from numpy import array
+  >>> geom = MultiPoint(array([[0.0, 0.0], [1.0, 2.0]]))
+  >>> geom # doctest: +ELLIPSIS
+  <shapely.geometry.multipoint.MultiPoint object at ...>
+  >>> len(geom.geoms)
+  2
+  >>> geom.wkt
+  'MULTIPOINT (0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000)'
+
+From coordinate tuples
+
+  >>> geom = MultiPoint(((1.0, 2.0), (3.0, 4.0)))
+  >>> len(geom.geoms)
+  2
+  >>> geom.wkt
+  'MULTIPOINT (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+From points
+
+  >>> geom = MultiPoint((Point(1.0, 2.0), Point(3.0, 4.0)))
+  >>> len(geom.geoms)
+  2
+  >>> print geom.wkt
+  MULTIPOINT (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)
+
+From another multi-point
+
+  >>> geom2 = MultiPoint(geom)
+  >>> len(geom2.geoms)
+  2
+  >>> print geom2.wkt
+  MULTIPOINT (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)
+
+
+Sub-geometry Access
+-------------------
+
+  >>> geom.geoms[0] # doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+  >>> geom.geoms[0].x
+  1.0
+  >>> geom.geoms[0].y
+  2.0
+  >>> geom.geoms[2]
+  Traceback (most recent call last):
+  ...
+  IndexError: index out of range
+
+Geo interface
+-------------
+
+  >>> geom.__geo_interface__
+  {'type': 'MultiPoint', 'coordinates': ((1.0, 2.0), (3.0, 4.0))}
+
+  >>> array(geom)
+  array([[ 1.,  2.],
+         [ 3.,  4.]])
+
+Adapter
+-------
+
+  >>> from shapely.geometry import asMultiPoint
+
+  Adapt a Numpy array to a multipoint
+
+  >>> a = array([[1.0, 2.0], [3.0, 4.0]])
+  >>> geoma = asMultiPoint(a)
+  >>> geoma.context
+  array([[ 1.,  2.],
+         [ 3.,  4.]])
+
+  >>> geoma.wkt
+  'MULTIPOINT (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+  Now, the inverse
+
+  >>> geoma.__array_interface__ == geoma.context.__array_interface__
+  True
+  >>> from numpy import asarray
+  >>> pas = asarray(geoma)
+  >>> pas
+  array([[ 1.,  2.],
+         [ 3.,  4.]])
+
+  Adapt a coordinate list to a line string
+
+  >>> coords = [[5.0, 6.0], [7.0, 8.0]]
+  >>> geoma = asMultiPoint(coords)
+  >>> geoma.wkt
+  'MULTIPOINT (5.0000000000000000 6.0000000000000000, 7.0000000000000000 8.0000000000000000)'
+  

shapely/tests/MultiPolygon.txt

@@ -0,0 +1,71 @@
+MultiPolygons
+=============
+
+Initialization
+--------------
+
+  >>> from shapely.geometry import Polygon, MultiPolygon
+
+From coordinate tuples
+
+  >>> geom = MultiPolygon( [
+  ... (((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)), [((0.25,0.25), (0.25,0.5), (0.5,0.5), (0.5,0.25))])
+  ... ] )
+  >>> geom # doctest: +ELLIPSIS
+  <shapely.geometry.multipolygon.MultiPolygon object at ...>
+  >>> len(geom.geoms)
+  1
+  >>> geom.wkt
+  'MULTIPOLYGON (((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000), (0.2500000000000000 0.2500000000000000, 0.2500000000000000 0.5000000000000000, 0.5000000000000000 0.5000000000000000, 0.5000000000000000 0.2500000000000000, 0.2500000000000000 0.2500000000000000)))'
+
+Or from polygons
+
+  >>> p = Polygon(((0, 0), (0, 1), (1, 1), (1, 0)), [((0.25,0.25), (0.25,0.5), (0.5,0.5), (0.5,0.25))])
+  >>> geom = MultiPolygon([p])
+  >>> len(geom.geoms)
+  1
+  >>> print geom.wkt
+  MULTIPOLYGON (((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000), (0.2500000000000000 0.2500000000000000, 0.2500000000000000 0.5000000000000000, 0.5000000000000000 0.5000000000000000, 0.5000000000000000 0.2500000000000000, 0.2500000000000000 0.2500000000000000)))
+
+Or from another multi-polygon
+
+  >>> geom2 = MultiPolygon(geom)
+  >>> len(geom2.geoms)
+  1
+  >>> print geom2.wkt
+  MULTIPOLYGON (((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000), (0.2500000000000000 0.2500000000000000, 0.2500000000000000 0.5000000000000000, 0.5000000000000000 0.5000000000000000, 0.5000000000000000 0.2500000000000000, 0.2500000000000000 0.2500000000000000)))
+
+Sub-geometry Access
+-------------------
+
+  >>> geom.geoms[0] # doctest: +ELLIPSIS
+  <shapely.geometry.polygon.Polygon object at ...>
+  >>> geom.geoms[0].wkt
+  'POLYGON ((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000), (0.2500000000000000 0.2500000000000000, 0.2500000000000000 0.5000000000000000, 0.5000000000000000 0.5000000000000000, 0.5000000000000000 0.2500000000000000, 0.2500000000000000 0.2500000000000000))'
+  >>> geom.geoms[1]
+  Traceback (most recent call last):
+  ...
+  IndexError: index out of range
+
+Geo interface
+-------------
+
+  >>> geom.__geo_interface__
+  {'type': 'MultiPolygon', 'coordinates': [(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)), ((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25), (0.25, 0.25)))]}
+
+Adapter
+-------
+
+  >>> from shapely.geometry import asMultiPolygon
+  >>> coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0))
+  >>> holes_coords = [((0.25,0.25), (0.25,0.5), (0.5,0.5), (0.5,0.25))]
+  >>> mpa = asMultiPolygon([(coords, holes_coords)])
+  >>> len(mpa.geoms)
+  1
+  >>> len(mpa.geoms[0].exterior.coords)
+  5
+  >>> len(mpa.geoms[0].interiors)
+  1
+  >>> len(mpa.geoms[0].interiors[0].coords)
+  5
+  

shapely/tests/Operations.txt

@@ -0,0 +1,89 @@
+Test GEOS operations
+====================
+
+  >>> from shapely.geometry import Point
+  >>> point = Point(0.0, 0.0)
+
+General geometry
+----------------
+
+  >>> point.area
+  0.0
+
+  >>> point.length
+  0.0
+
+  >>> point.distance(Point(-1.0, -1.0))
+  1.4142135623730951
+
+Topology operations
+-------------------
+
+  Envelope
+
+  >>> point.envelope #doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+
+  Intersection
+
+  >>> point.intersection(Point(-1,-1)) #doctest: +ELLIPSIS
+  <shapely.geometry.collection.GeometryCollection object at ...>
+  
+  Buffer
+
+  >>> point.buffer(10.0) #doctest: +ELLIPSIS
+  <shapely.geometry.polygon.Polygon object at ...>
+  
+  >>> point.buffer(10.0, 32) #doctest: +ELLIPSIS
+  <shapely.geometry.polygon.Polygon object at ...>
+
+  Simplify
+
+  >>> from shapely.wkt import loads
+  >>> p = loads('POLYGON ((120 120, 121 121, 122 122, 220 120, 180 199, 160 200, 140 199, 120 120))')
+  >>> expected = loads('POLYGON ((120 120, 140 199, 160 200, 180 199, 220 120, 120 120))')
+  >>> s = p.simplify(10.0, preserve_topology = False)
+  >>> s.equals_exact(expected, 0.001)
+  True
+
+  >>> from shapely.wkt import loads
+  >>> p = loads('POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))')
+  >>> expected = loads('POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))')
+  >>> s = p.simplify(10.0, preserve_topology = True)
+  >>> s.equals_exact(expected, 0.001)
+  True
+
+  Convex Hull
+
+  >>> point.convex_hull #doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+  
+  Differences
+
+  >>> point.difference(Point(-1, 1)) #doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+  
+  >>> point.symmetric_difference(Point(-1, 1)) #doctest: +ELLIPSIS
+  <shapely.geometry.multipoint.MultiPoint object at ...>
+  
+  Boundary
+
+  >>> point.boundary #doctest: +ELLIPSIS
+  <shapely.geometry.collection.GeometryCollection object at ...>
+  
+  Union
+
+  >>> point.union(Point(-1, 1)) #doctest: +ELLIPSIS
+  <shapely.geometry.multipoint.MultiPoint object at ...>
+
+  >>> point.representative_point() #doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+
+  >>> point.centroid #doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+
+  Relate
+
+  >>> point.relate(Point(-1, -1)) #doctest: +ELLIPSIS
+  'FF0FFF0F2'
+

shapely/tests/Operators.txt

@@ -0,0 +1,18 @@
+Test operators
+==============
+
+  >>> from shapely.geometry import Point
+  >>> point = Point(0, 0)
+  >>> point2 = Point(-1, 1)
+
+  >>> point.union(point2).equals(point | point2)
+  True
+
+  >>> (point & point2).is_empty
+  True
+
+  >>> point.equals(point - point2)
+  True
+
+  >>> point.symmetric_difference(point2).equals(point ^ point2)
+  True