def __init__(self, start, radius, rotation, large_arc, sweep, end,<EOL>autoscale_radius=True):
assert start != end<EOL>assert radius.real != <NUM_LIT:0> and radius.imag != <NUM_LIT:0><EOL>self.start = start<EOL>self.radius = abs(radius.real) + <NUM_LIT>*abs(radius.imag)<EOL>self.rotation = rotation<EOL>self.large_arc = bool(large_arc)<EOL>self.sweep = bool(sweep)<EOL>self.end = end<EOL>self.autoscale_radius = autoscale_radius<EOL>self.phi = radians(self.rotation)<EOL>self.rot_matrix = exp(<NUM_LIT>*self.phi)<EOL>self._parameterize()<EOL>
This should be thought of as a part of an ellipse connecting two
points on that ellipse, start and end.
Parameters
----------
start : complex
    The start point of the curve. Note: `start` and `end` cannot be the
    same.  To make a full ellipse or circle, use two `Arc` objects.
radius : complex
    rx + 1j*ry, where rx and ry are the radii of the ellipse (also
    known as its semi-major and semi-minor axes, or vice-versa or if
    rx < ry).
    Note: If rx = 0 or ry = 0 then this arc is treated as a
    straight line segment joining the endpoints.
    Note: If rx or ry has a negative sign, the sign is dropped; the
    absolute value is used instead.
    Note:  If no such ellipse exists, the radius will be scaled so
    that one does (unless autoscale_radius is set to False).
rotation : float
    This is the CCW angle (in degrees) from the positive x-axis of the
    current coordinate system to the x-axis of the ellipse.
large_arc : bool
    Given two points on an ellipse, there are two elliptical arcs
    connecting those points, the first going the short way around the
    ellipse, and the second going the long way around the ellipse.  If
    `large_arc == False`, the shorter elliptical arc will be used.  If
    `large_arc == True`, then longer elliptical will be used.
    In other words, `large_arc` should be 0 for arcs spanning less than
    or equal to 180 degrees and 1 for arcs spanning greater than 180
    degrees.
sweep : bool
    For any acceptable parameters `start`, `end`, `rotation`, and
    `radius`, there are two ellipses with the given major and minor
    axes (radii) which connect `start` and `end`.  One which connects
    them in a CCW fashion and one which connected them in a CW
    fashion.  If `sweep == True`, the CCW ellipse will be used.  If
    `sweep == False`, the CW ellipse will be used.  See note on curve
    orientation below.
end : complex
    The end point of the curve. Note: `start` and `end` cannot be the
    same.  To make a full ellipse or circle, use two `Arc` objects.
autoscale_radius : bool
    If `autoscale_radius == True`, then will also scale `self.radius`
    in the case that no ellipse exists with the input parameters
    (see inline comments for further explanation).

Derived Parameters/Attributes
-----------------------------
self.theta : float
    This is the phase (in degrees) of self.u1transform(self.start).
    It is $\theta_1$ in the official documentation and ranges from
    -180 to 180.
self.delta : float
    This is the angular distance (in degrees) between the start and
    end of the arc after the arc has been sent to the unit circle
    through self.u1transform().
    It is $\Delta\theta$ in the official documentation and ranges from
    -360 to 360; being positive when the arc travels CCW and negative
    otherwise (i.e. is positive/negative when sweep == True/False).
self.center : complex
    This is the center of the arc's ellipse.
self.phi : float
    The arc's rotation in radians, i.e. `radians(self.rotation)`.
self.rot_matrix : complex
    Equal to `exp(1j * self.phi)` which is also equal to
    `cos(self.phi) + 1j*sin(self.phi)`.


Note on curve orientation (CW vs CCW)
-------------------------------------
The notions of clockwise (CW) and counter-clockwise (CCW) are reversed
in some sense when viewing SVGs (as the y coordinate starts at the top
of the image and increases towards the bottom).