Attempt to use autoclass

This is an attempt to use autoclass for axis-aligned line. This should be
nearly parity and, to help compare, includes both the auto generated
documentation and the old style documentation.

This also fixes some non-command wording in axis-aligned line

* docs/Geometry.rst - Fix incorrect reST and minor wording improvements.
Also add autoclass for AxisAlignedLine.

* pygorithm/geometry/axisall.py - Add function skeletons and (hopefully)
something resembling parity to documentation in Geometry.rst

Author: Tjstretchalot

docs/Geometry.rst

@@ -59,7 +59,7 @@ Features
 Vector2
 -------
 
-.. class: Vector2
+.. class:: Vector2
 
 Defines a simple two-dimensional, mutable vector.
 
@@ -229,12 +229,12 @@ Example:
 The named argument "degrees" or "radians" may be passed in to rotate 
 this vector by the specified amount in degrees (or radians), 
 respectively. If both are omitted, the first unnamed argument is 
-assummed to be the amount to rotate in radians. 
+assumed to be the amount to rotate in radians. 
 
 Additionally, the named argument "about" may be passed in to specify 
 about what the vector should be rotated. If omitted then the first 
 unconsumed unnamed argument is assumed to be the vector. If there are 
-no unconsumed unamed arguments then the origin is assumed. 
+no unconsumed unnamed arguments then the origin is assumed. 
 
 Examples:
 
@@ -417,24 +417,24 @@ Defines an undirected two-dimensional line by an axis, a minimum and a maximum.
 .. note::
 
     `min` and `max` are referring to nearness to negative and positive infinity,
-    respectively. The absolute value of `min` may be larger than `max`.
+    respectively. The absolute value of `min` may be larger than that of `max`.
 
 .. note::
 
-    `AxisAlignedLine`s are an intermediary operation, so offsets should be baked 
+    AxisAlignedLines are an intermediary operation, so offsets should be baked 
     into them.
 
-.. attribute AxisAlignedLine.axis
+.. attribute:: AxisAlignedLine.axis
 
     `Vector2` the axis this line is along.
 
-.. attribute AxisAlignedLine.min
+.. attribute:: AxisAlignedLine.min
 
     `numeric` the number (closest to negative infinity) that is still on this 
     line when walked along the axis. If negative, it may have a greater absolute
     value than max and implies walking in the opposite direction of the axis.
 
-.. attribute AxisAlignedLine.max
+.. attribute:: AxisAlignedLine.max
 
     `numeric` the number (closest to positive infinity) that is still on this 
     line when walked along the axis. If negative, it may have a smaller absolute
@@ -446,16 +446,18 @@ Defines an undirected two-dimensional line by an axis, a minimum and a maximum.
     - **point1**  - `numeric` one point on this line
     - **point2**  - `numeric` a different point on this line
 
-    Constructs an axis aligned line with the appropriate min and max.
+    Construct an axis aligned line with the appropriate min and max.
 
 .. staticmethod:: AxisAlignedLine.intersects(line1, line2)
 
     - **line1**        - `AxisAlignedLine` the first line
     - **line2**        - `AxisAlignedLine` the second line
     - **Return Value** - `bool, bool` touching, overlapping
 
-    Determines if the two lines are touching and if they are, if 
-    they are overlapping. 
+    Determine if the two lines are touching and if they are, if 
+    they are overlapping. Lines are touching if they share only
+    one end point, whereas they are overlapping if they share
+    infinitely many points.
 
     .. note::
 
@@ -469,7 +471,7 @@ Defines an undirected two-dimensional line by an axis, a minimum and a maximum.
     - **line2**        - `AxisAlignedLine` the second line
     - **Return Value** - `bool, numeric or None` touching, mtv against 1
 
-    Determines if the two lines are touching, and then returns the 
+    Determine if the two lines are touching, and then returns the 
     minimum translation vector to move line 1 along axis. If the result
     is negative, it means line 1 should be moved in the opposite direction
     of the axis by the magnitude of the result.
@@ -484,11 +486,17 @@ Defines an undirected two-dimensional line by an axis, a minimum and a maximum.
 
     - **line**         - `AxisAlignedLine` the line
     - **point**        - `numeric` the point 
-    - **Return Value** - `bool` if point is contained (or an edge of) the line
+    - **Return Value** - `bool, bool` if point is contained, if the point is an edge
 
-    Determines if the line contains the specified point, which is assumed 
+    Determine if the line contains the specified point, which is assumed 
     to be defined the same way as min and max.
 
+Axis-Aligned Line (autogen)
+---------------------------
+
+.. autoclass:: pygorithm.geometry.AxisAlignedLine
+    :members:
+    
 Concave Polygon
 ---------------
 

pygorithm/geometry/axisall.py

@@ -0,0 +1,131 @@
+"""
+axisall
+
+Author: Timothy Moore
+
+Defines a class for handling axis-aligned two-dimensional lines 
+segments. This class simplifies intermediary calculations in
+SAT and similiar algorithms.
+
+These are 2dimensional axis-aligned objects
+https://en.wikipedia.org/wiki/Axis-aligned_object
+"""
+
+class AxisAlignedLine(object):
+    """
+    Define an axis aligned line.
+    
+    This class provides functions related to axis aligned lines as well as 
+    acting as a convienent container for them. In this context, an axis 
+    aligned line is a two-dimensional line that is defined by an axis and 
+    length on that axis, rather than two points. When working with two lines 
+    defined as such that have the same axis, many calculations are 
+    simplified. 
+
+    .. note::
+
+        Though it requires the same amount of memory as a simple representation of
+        a 2 dimensional line (4 numerics), it cannot describe all types of lines.
+        All lines that can be defined this way intersect (0, 0).
+    
+    .. note::
+    
+        `min` and `max` are referring to nearness to negative and positive infinity,
+        respectively. The absolute value of `min` may be larger than that of `max`.
+
+    .. note::
+
+        AxisAlignedLines are an intermediary operation, so offsets should be baked 
+        into them.
+    
+    :ivar axis: the axis this line is on
+    :ivar min: the point closest to negative infinity
+    :ivar max: the point closest to positive infinity
+    """
+    
+    def __init__(self, axis, point1, point2):
+        """
+        Construct an axis aligned line with the appropriate min and max.
+        
+        :param axis: axis this line is on
+        :type axis: :class:`pygorithm.geometry.Vector2`
+        :param point1: one point on this line
+        :type point1: :class:`numbers.Number`
+        :param point2: a different point on this line
+        :type point2: :class:`numbers.Number`
+        """
+    
+        pass
+    
+    @staticmethod
+    def intersects(line1, line2):
+        """
+        Determine if the two lines intersect
+        
+        Determine if the two lines are touching and if they are, if 
+        they are overlapping. Lines are touching if they share only
+        one end point, whereas they are overlapping if they share
+        infinitely many points.
+        
+        .. note::
+        
+            It is rarely faster to check intersection before finding intersection if
+            you will need the minimum translation vector, since they do mostly 
+            the same operations.
+        
+        :param line1: the first line
+        :type line1: :class:`pygorithm.geometry.AxisAlignedLine`
+        :param line2: the second line
+        :type line2: :class:`pygorithm.geometry.AxisAlignedLine`
+        :returns: touching, overlapping
+        :rtype: bool, bool
+        """
+        
+        pass
+    
+    @staticmethod
+    def find_intersection(line1, line2):
+        """
+        Calculate the MTV between line1 and line2 to move line1
+        
+        Determine if the two lines are touching, and then returns the 
+        minimum translation vector to move line 1 along axis. If the result
+        is negative, it means line 1 should be moved in the opposite direction
+        of the axis by the magnitude of the result.
+        
+        Returns `true, None` if the lines are touching.
+        
+        .. note::
+        
+            Ensure your program correctly handles `true, None`
+        
+        
+        :param line1: the first line
+        :type line1: :class:`pygorithm.geometry.AxisAlignedLine`
+        :param line2: the second line
+        :type line2: :class:`pygorithm.geometry.AxisAlignedLine`
+        :returns: touching, mtv against 1
+        :rtype: bool, :class:`numbers.Number` or None
+        """
+        
+        pass
+    
+    @staticmethod
+    def contains_point(line, point):
+        """
+        Determine if the line contains the specified point.
+        
+        The point must be defined the same way as min and max.
+        
+        .. tip::
+        
+            It is not possible for both returned booleans to be `True`.
+        
+        :param line: the line
+        :type line: :class:`pygorithm.geometry.AxisAlignedLine`
+        :param point: the point
+        :type point: :class:`numbers.Number`
+        :returns: if the point is an edge of the line, if the point is contained by the line
+        :rtype: bool, bool
+        """
+        pass