Example #1
0
def mobTransform(*args,**kws):
    __sigs__=  [[list,list,list],
               [Complex._zCircle,list], [Complex._zPoint,list],
               [Complex._zCircle,Complex._zCircle,list],[list],
               [Complex._zPoint,float,list]]

    t,i = method_get(__sigs__,args)
    if t is None:
       raise Argument_Type_Error(__sigs__,args)
    else:
       if i==0:
          if (len(t[0])==3 and len(t[1])==3): 
             return mobPointSets(t[0],t[1],t[2],**kws)     
       elif i==1:
          return mobUnitCircle(t[0],t[1],**kws)
       elif i==2:
          alt=kws.get("alt")
          if alt:
             if alt==TRANSLATE:
                return mobTranslate(t[0],t[1],**kws)
             elif alt==MULTIPLY:
                return mobMultiply(t[0],t[1],**kws)
             else:
                raise Argument_Type_Error(__sigs__,args)
          else:
             return mobMultiply(t[0],t[1],**kws)
       elif i==3:
          return mobMapCircles(t[0],t[1],t[2],**kws)
       elif i==4:
          return mobReciprocate(t[0],**kws)
       elif i==5:
          return mobRotate(t[0],t[1],t[2],**kws)
       else:
          raise Argument_Type_Error(__sigs__,args)
Example #2
0
def  Chord(*args,**kws):
   """
:constructors:

   - Chord(circle,line); calls: `class CircleChord`_
   - Chord(sphere,line); calls: `class SphereChord`_
   - Chord(circle1,circle2); calls: `class BiChord`_

:returns: An instance of an object derived from the `_Line`_ abstract class,
          representing a  line in space with its 'p1' nnd 'p2' attributes on
          a given circle_ or sphere_
   """
   __sigs__=[[Real._Circle,Real._Line],[Real._Sphere,Real._Line],
             [Real._Circle,Real._Circle],[Conic,Real._Line]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return CircleChord(t[0],t[1],**kws)
      elif i==1:
         return SphereChord(t[0],t[1],**kws)
      elif i==2:
         return BiChord(t[0],t[1],**kws)
      elif i==3:
         return ConicChord(t[0],t[1],**kws)

      else:
         raise Argument_Type_Error(__sigs__,args)
Example #3
0
def  Sphere(*args,**kws):
   """
:constructors:

   - Sphere(point1,point2); calls: `class CenterSphere`_
   - Sphere((sphere,point);  calls: `class OrthoSphere`_
   - Sphere((point1,point2,point3,point4); calls: `class CircumSphere`_

:returns: An instance of an object derived from the `_Sphere`_ abstract class,
          representing all points in space equidistant from a given point
   """
   __sigs__=[[vector,vector],[Real._Sphere,vector],
             [vector,vector,vector,vector]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i == 0:
         return CenterSphere(t[0],t[1],**kws)
      elif i == 1:
         return OrthoSphere(t[0],t[1],**kws)
      elif i==2:
         return CircumSphere(t[0],t[1],t[2],t[3],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #4
0
def  Slider(*args,**kws):
   """
:constructors:

   - Slider(line, <ratio = numeric> ); calls: `class LineSlider`_
   - Slider(plane, <[numeric,numeric,numeric]>); calls: `class PlaneSlider`_
   - Slider(circle, <angle = numeric>); calls: `class CircleSlider`_
   - Slider(sphere,<theta= numeric, phi = numeric>); calls: `class SphereSlider`_

:returns: A point_ that is pickable, with movement constrained with reference
          to a given geometric object
   """
   __sigs__ = [[Real._Line],[Real._Plane],
               [Real._Plane,float,float,float],[Real._Circle,float,float,float],
               [Real._Plane,list],[Real._Plane,tuple],
               [Real._Circle,list],[Real._Circle,tuple],
               [Real._Circle],[Real._Sphere]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
     if i == 0:
        return LineSlider(t[0],**kws)
     elif i==1:
        return PlaneSlider(t[0],**kws)
     elif i==2 or i==3:
        return PlaneSlider(t[0],t[1],t[2],t[3],**kws)
     elif i==4 or i==5 or i==6 or i==7:
        return PlaneSlider(t[0],t[1][0],t[1][1],t[1][1],**kws)
     elif i==8:
        return CircleSlider(t[0],**kws)
     elif i==9:
        return SphereSlider(t[0],**kws)
     else:
         raise Argument_Type_Error(__sigs__,args)
Example #5
0
def uSlider(*args,**kws):
    """
:constructors: 

  - uSlider(<float>, <float);  calls: `class uSphereSlider`_
  - uSlider(uCircle,<float>);  calls: `class uCircleSlider`_
  
:returns: A point of the origin centered `Riemann sphere`_ that can be picked and moved,
          with initial position and constraints as determined by its arguments.
          
:site ref: http://mathworld.wolfram.com/UnitSphere.html
    """
    __sigs__=[[],[float],[float,float],
              [USphere._uCircle],[USphere._uCircle,float]]
    t,i = method_get(__sigs__,args)
    if t is None:
       raise Argument_Type_Error(__sigs__,args)
    else:
       if i==0:
          return uSphereSlider(**kws)
       elif i==1:
          return uSphereSlider(t[0],**kws)
       elif i==2:
          return uSphereSlider(t[0],t[1],**kws)
       elif i==3:
          return uCircleSlider(t[0],**kws)
       elif i==4:
          return uCircleSlider(t[0],t[1],**kws)

       else:
          raise Argument_Type_Error(__sigs__,args)
Example #6
0
def Intersect(*args,**kws):
   """
:constructors:

  - Intersect(plane, line);  calls: `class PlaneLineIntersect`_
  - Intersect(line,line);  calls: `class LinesIntersect`_
  - Intersect(plane1,plane2,plane3); calls:`class PlanesIntersect`_

:returns: A point_ instance determined as an intersection_ of its arguments

:site ref: http://mathworld.wolfram.com/Intersection.html
   """
   __sigs__=[[Real._Plane,Real._Line],[Real._Circle,Real._Line],
             [Real._Line,Real._Line],
             [Real._Plane,Real._Plane,Real._Plane]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0 or i==1:
         return PlaneLineIntersect(t[0],t[1],**kws)
      elif i==2:
         return LinesIntersect(t[0],t[1],**kws)
      elif i==3:
         return PlanesIntersect(t[0],t[1],t[2],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #7
0
def Inversion(*args,**kws):
   """
:constructors:

  - Inversion(point,circle);  calls: `class CircleInversion`_
  - Inversion(point,sphere);  calls: `class SphereInversion`_
  - Inversion(line, circle);  calls: `class CirclePole`_
  - Inversion(plane, sphere); calls: `class SpherePole`_
  - Inversion(line, conic): calls: :calls: `class ConicPole`_

:returns: A point determined by a inversive_ transformation with respect to a
          given geometric object

:site ref: http://mathworld.wolfram.com/InversiveGeometry.html
   """
   __sigs__=[[Real._Plane,Real._Sphere],[Real._Circle,Real._Sphere],[Real._Line,Real._Circle],
            [Real._Line,Conic],[vector,Real._Circle],[vector,Real._Sphere]]
   t,i=method_get(__sigs__,args)
   if t is  None:
     raise Argument_Type_Error(__sigs__,args)
   else:
     if i==0 or i==1:
        return SpherePole(t[0],t[1],**kws)
     elif i==2:
        return CirclePole(t[0],t[1],**kws)
     elif i==2:
        return CirclePole(t[0],t[1],**kws)
     elif i==3:
        return ConicPole(t[0],t[1],**kws)
     elif i==4:
        return CircleInversion(t[0],t[1],**kws)
     elif i==5:
        return SphereInversion(t[0],t[1],**kws)
     else:
        raise Argument_Type_Error(__sigs__,args)
Example #8
0
def uCircle(*args,**kws):
   """
:constructors: 

  - uCircle(uPoint,uPoint,uPoint);  calls: `class uCircumCircle`_
  - uCircle(point,point);  calls: `class uCircleFromNormal`_
  - uCircle(point);  calls: `class uPolarCircle`_
  - uCircle(zCircle);  calls: `class z_to_uCircle`_
  - uCircle(zLine);  calls: `class z_to_uCircle`_
  
  
:returns: A `spheric section`_ of the `Riemann sphere`_
          
:site ref: http://mathworld.wolfram.com/SphericSection.html
   """   
   __sigs__=[[USphere._uPoint,USphere._uPoint,USphere._uPoint],
               [Real._Point,Real._Point],
               [Real._Point],
               [Complex._zCircle],[Complex._zLine]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return uCircumCircle(t[0],t[1],t[2],**kws)
      elif i==1:
         return uCircleFromNormal(t[0],t[1],**kws)
      elif i==2:
         return uPolarCircle(t[0],**kws)
      elif i==3 or i==4:
         return z_to_uCircle(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #9
0
def zAniPoint(*args,**kws):
   """
:constructors: 


  - zAniPoint(zcircle,<rate=integer>,<angle=numeric>); calls `class zCirclingPoint`_
  - zAniPoint(zline, <rate=integer>,<ratio=numeric>); calls `class zSlidingPoint`_ 
  - zAniPoint(zpoint,zpoint,<rate=integer>); calls `class zRotatingPoint`_ 

:returns: a point which moves constrained to a given geometric object of the `complex plane`_
          at each display update cycle, with the initial position and rate of movement
          determinable by keyword argument.

   """

   __sigs__ = [[Complex._zCircle],[Complex._zLine],
                [Complex._zPoint,Complex._zPoint]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i == 0:
         return zCirclingPoint(t[0],**kws)
      elif i == 1:
         return zSlidingPoint(t[0],**kws)
      elif i == 2:
         return zRotatingPoint(t[0],t[1],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #10
0
def AntiPodal(*args,**kws):
   """
:constructors:

    - AntiPodal(circle,point); calls: `class CircleAntiPodal`_
    - AntiPodal(line,point); calls: `class Segpoint`_
    - AntiPodal(sphere,point); calls: `class SphereAntiPodal`_

:returns: A point_ instance determined as antipodal_ to a given point_ on a
          given geometric object

:site ref: http://mathworld.wolfram.com/AntipodalPoints.html
   """
   __sigs__=__sigs__=[[Real._Circle,vector],[Real._Sphere,vector],
                      [Real._Line,vector],[Real._Line]]
   t,i=method_get(__sigs__,args)
   if t is  None:
     raise Argument_Type_Error(__sigs__,args)
   else:
     if i==0:
        return CircleAntiPodal(t[0],t[1],**kws)
     elif i==1:
        return SphereAntiPodal(t[0],t[1],**kws)
     elif i==2:
        return SegPoint(t[0],t[1],**kws)
     elif i==3:
        return SegPoint(t[0],**kws)
     else:
        raise Argument_Type_Error(__sigs__,args)
Example #11
0
def uPoint(*args,**kws):
   """
:constructors: 

  - uPoint(<float>, <float>);  calls: `class uPolarPoint`_
  - uPoint(uPoint);  calls: `class uAntipodal`_
  - uPoint(zPoint); calls:`class z_to_uPoint`_
  - uPoint(uCircle,uPoint); calls:`class uInversePoint`_
  
:returns: A point of the origin centered 'unit sphere'_, as determined by its arguments

:site ref: http://mathworld.wolfram.com/UnitSphere.html
   """
   __sigs__=[[],[float],[float,float],
             [USphere._uPoint],
             [Complex._zPoint],
             [USphere._uCircle,USphere._uPoint]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return uPolarPoint(**kws)
      elif i==1:
         return uPolarPoint(t[0],**kws)
      elif i==2:
         return uPolarPoint(t[0],t[1],**kws)
      elif i==3:
         return uAntiPodal(t[0],**kws)
      elif i==4:
         return z_to_uPoint(t[0],**kws)
      elif i==5:
         return uInversePoint(t[0],t[1],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #12
0
def zCircle(*args, **kws):
    """
:constructors: 

   - zCircle();                                          calls: `class zUnitCircle`_
   - zCircle(zpoint1,zpoint2);                           calls: `class zCircleFromPoints`_
   - zCircle(zpoint1,zpoint2,zpoint3);                   calls: `class zCircumCircle`_
   - zCircle(zcircle,zpoint);                            calls: `class zOrthoCircle`_
   - zCircle(zcircle,zpoint1,zpoint2);                   calls: `class zOrthoCircle_Circum`_
   - zCircle(zcircle1,zcircle2,<alt=INVERSE>);           calls: `class zInverseCircle`_
   - zCircle(ucircle);                                   calls: `class u_to_zCircle`_
   - zCircle(zcircle1,zcircle2,alt=FUNDAMENTAL);         calls: `class zFundamentalCircle`_
 
:returns: an instance of an object derived from the `_zCircle`_ abstract class, determined
          uniquely by reference to its arguments  

**Keyword arguments**: see `_zCircle`_
   """
    __sigs__ = [
        [Complex._zPoint, Complex._zPoint],
        [Complex._zPoint, Complex._zPoint, Complex._zPoint],
        [Complex._zCircle, Complex._zPoint],
        [Complex._zCircle, Complex._zPoint, Complex._zPoint],
        [Complex._zCircle, Complex._zCircle],
        [USphere._uCircle],
        [],
    ]
    t, i = method_get(__sigs__, args)
    if t is None:
        raise Argument_Type_Error(__sigs__, args)
    else:
        if i == 0:
            return zCircleFromPoints(t[0], t[1], **kws)
        elif i == 1:
            return zCircumCircle(t[0], t[1], t[2], **kws)
        elif i == 2:
            return zOrthoCircle(t[0], t[1], **kws)
        elif i == 3:
            return zOrthoCircle_Circum(t[0], t[1], t[2], **kws)
        elif i == 4:
            alt = kws.get("alt")
            if alt:
                if alt == FUNDAMENTAL:
                    return zFundamentalCircle(t[0], t[1], **kws)
                elif alt == INVERSE:
                    return zInverseCircle(t[0], t[1], **kws)
                else:
                    raise Argument_Type_Error(__sigs__, args)
            else:
                return zInverseCircle(t[0], t[1], **kws)
        elif i == 5:
            return u_to_zCircle(t[0], **kws)
        elif i == 6:
            return zUnitCircle(**kws)
        else:
            raise Argument_Type_Error(__sigs__, args)
Example #13
0
def PointArray(*args, **kws):
    """
:constructors:

   - PointArray(line); calls: `class SegmentPencil`_
   - PointArray(line_array,line); calls: `class CirclingPencil`_
   - PointArray(circle); calls: `class CirclePoints`_
   - PointArray(line_array1,line_array2); calls: `class ArrayIntersect`_
   - PointArray(point1,point2,point3); calls: `class Harmonics`_
   - PointArray(point1,point2,point3,point4); calls: `class GrowthMeasure`_
   - PointArray(point1,point2,point3,point4,point5); calls: `class Conic`_
   - PointArray(conic,linearray); calls: `class CorrelationPoints`_
   - PointArray(plane,linearray); calls: `class PlanePoints`_

:returns: An instance of an object derived from the `_Line`_ abstract class,
          representing an infinite line in space, or, in context, the line segment
          between the line 'p1' nnd 'p2' attributes.
   """
    __sigs__ = [
        [Real._Line],
        [Real._LineArray, Real._Line],
        [Real._Circle],
        [vector, vector, vector, vector, vector],
        [Real._LineArray, Real._LineArray],
        [vector, vector, vector, vector],
        [Real._PointArray, vector, vector],
        [Conic, Real._LineArray],
        [Real._Plane, Real._LineArray],
    ]
    t, i = method_get(__sigs__, args)
    if t is None:
        raise Argument_Type_Error(__sigs__, args)
    else:
        if i == 0:
            return PointPencil(t[0], **kws)
        elif i == 1:
            return CirclingPencil(t[0], t[1], **kws)
        elif i == 2:
            return CirclePoints(t[0], **kws)
        elif i == 3:
            return Conic(t[0], t[1], t[2], t[3], t[4], **kws)
        elif i == 4:
            return ArrayIntersect(t[0], t[1], **kws)
        elif i == 5:
            return GrowthMeasure(t[0], t[1], t[2], t[3], **kws)
        elif i == 6:
            return Harmonics(t[0], t[1], t[2], **kws)
        elif i == 7:
            return CorrelationPoints(t[0], t[1], **kws)
        elif i == 8:
            return PlanePoints(t[0], t[1], **kws)
        else:
            raise Argument_Type_Error(__sigs__, args)
Example #14
0
def zCirclePencil(*args,**kws):
     __sigs__=[[Complex._zCircle,Complex._zCircle],
               [USphere._uCirclePencil]]
     t,i = method_get(__sigs__,args)
     if t is None:
        raise Argument_Type_Error(__sigs__,args)
     else:
        if i==0:
           return zCircles(t[0],t[1],**kws)
        elif i==1:
           return u_to_zCirclePencil(t[0],**kws)
        else:
           raise Argument_Type_Error(__sigs__,args)
Example #15
0
def  Plane(*args,**kws):
   """
:constructors:

   - Plane(point1,point2,point3); calls: `class PlanefromPoints`_
   - Plane(point1,point2,point3,PLANE); calls: `class PlanefromPoints`_
   - Plane(point1,point2,point3,TRIANGLE); calls: `class Triangle`_
   - Plane(plane,point1); calls: `class ParaPointPlane`_
   - Plane(line1,line2,point); calls: `class ParaLinesPlane`_
   - Plane(point1,point2,line); calls: `class ParaPointsLinePlane`_
   - Plane(point1,point2); calls: `class PlaneFromNormal`_
   - Plane(plane,point1,point2); calls: `class PerpPlane`_
   - Plane(sphere,point); calls: `class PolarPlane`_

:returns: An instance of an object derived from the `_Plane`_ abstract class,
          representing an infinite plane_ in space.
   """

   __sigs__=[[vector,vector,vector],[Real._Plane,vector],
              [Real._Circle,vector],[Real._Line,Real._Line,vector],
              [vector,vector,Real._Line],
              [Real._Plane,vector,vector],
              [Real._Circle,vector,vector],[vector,vector],
              [Real._Sphere,vector],[vector,vector,vector,float]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i == 0:
         return PlaneFromPoints(t[0],t[1],t[2],**kws)
      elif i == 1 or i==2:
         return ParaPointPlane(t[0],t[1],**kws)
      elif i == 3:
         return ParaLinesPlane(t[0],t[1],t[2],**kws)
#      elif i == 4:
#         return ParaPointsLinePlane(t[0],t[1],t[2],**kws)
      elif i == 5 or i==6:
         return PerpPlane(t[0],t[1],t[2],**kws)
      elif i==7:
         return PlaneFromNormal(t[0],t[1],**kws)
      elif i==8:
         return PolarPlane(t[0],t[1],**kws)
      elif i==9:
         if t[3] == 0:
            return PlaneFromPoints(t[0],t[1],t[2],**kws)
         elif t[3] ==1:
            return Triangle(t[0],t[1],t[2],**kws)
         else:
            raise Argument_Type_Error(__sigs__,args)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #16
0
def Line(*args, **kws):
    """
:constructors:

   - Line(point1,point2); calls: `class LinefromPoints`_
   - Line(plane,point); calls: `class PlanePerp`_
   - Line(plane1,plane2); calls: `class PlanesLine`_
   - Line(line,point); calls: `class ParaLine`_
   - Line(line1,line2); calls: `class NearLine`_
   - Line(line1,line2,point); calls: `class Transversal`_
   - Line(conic,point); calls: `class ConicPolar`_
   """
    __sigs__ = [
        [vector, vector],
        [Real._Plane, vector],
        [Real._Plane, Real._Plane],
        [Real._Line, vector],
        [Real._Line, Real._Line],
        [Real._Line, Real._Line, vector],
        [Conic, vector],
        [vector, vector, vector],
        [vector, Real._Circle],
    ]
    t, i = method_get(__sigs__, args)
    if t is None:
        raise Argument_Type_Error(__sigs__, args)
    else:
        if i == 0:
            return LineFromPoints(t[0], t[1], **kws)
        elif i == 1:
            return PlanePerp(t[0], t[1], **kws)
        elif i == 2:
            return PlanesLine(t[0], t[1], **kws)
        elif i == 3:
            return ParaLine(t[0], t[1], **kws)
        elif i == 4:
            return NearLine(t[0], t[1], **kws)
        elif i == 5:
            return Transversal(t[0], t[1], t[2], **kws)
        elif i == 6:
            return ConicPolar(t[0], t[1], **kws)
        elif i == 7:
            return LinePerp(t[0], t[1], t[2], **kws)
        elif i == 8:
            return CirclePolar(t[0], t[1], **kws)

        else:
            raise Argument_Type_Error(__sigs__, args)
Example #17
0
def zLineArray(*args, **kws):
    """
:constructors: 

   - zLineArray(zpoint); calls: `class zLinePencil`_

:returns: An instance of an object derived from the `_zLineArray`_ abstract class,
          representing an array infinite lines of the `complex plane`_
   """
    __sigs__ = [[Complex._zPoint]]
    t, i = method_get(__sigs__, args)
    if t is None:
        raise Argument_Type_Error(__sigs__, args)
    else:
        if i == 0:
            return zLinePencil(t[0], **kws)
        else:
            raise Argument_Type_Error(__sigs__, args)
Example #18
0
def  LineArray(*args,**kws):
   """
:constructors:

   - LineArray(point,plane); calls: `class CirclingLines`_
   - LineArray(pointarray,line1,line2); calls: `class Regulus`_
   - LineArray(pointarray1,pointarray2); calls: `class ArrayMap`_
   - LineArray(planepencil1,planepencil2); calls: `class PlanesPencilIntersect`_
   - LineArray(pointarray,point); calls: `class Lines`_
   - LineArray(conic,pointarray); calls: `class CorrelationLines`_

:returns: An instance of an object derived from the `_Line`_ abstract class,
          representing an infinite line in space, or, in context, the line segment
          between the line 'p1' nnd 'p2' attributes.

   """
   __sigs__=[[Real._PointArray,vector],[vector,Real._Plane],
              [vector,Real._Circle],[Real._PointArray,Real._Line,Real._Line],
              [list,list],
              [Real._PointArray,Real._PointArray],[Real._PlaneArray,Real._PlaneArray],
              [Conic,Real._PointArray]]

   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i ==0:
         return Lines(t[0],t[1],**kws)
      elif i==1 or i==2:
         return LinePencil(t[0],t[1],**kws)
      elif i==3:
         return Regulus(t[0],t[1],t[2],**kws)
      elif i==4:
         return PointMap(t[0],t[1],**kws)
      elif i==5:
         return ArrayMap(t[0],t[1],**kws)
      elif i==6:
         return PlanesPencilIntersect(t[0],t[1],**kws)
      elif i==7:
         return CorrelationLines(t[0],t[1],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #19
0
def  PlaneArray(*args,**kws):
   """
:constructors:

     - PlanePencil(list)
     - PlaneArray(list)

:returns:  the set of planes through the given line

:site ref: http://mathworld.wolfram.com/SheafofPlanes.html
   """
   __sigs__=[[Real._Line]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return PlanePencil(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #20
0
def  CircleArray(*args,**kws):
   """
:constructors:

     - CiclePencil(sphere,planearray)
     - CicleArray(sphere,planearray)

:returns:  the set of circles which the `plane sheaf`_ cuts from the sphere. See SphereCircle_

:site ref: http://mathworld.wolfram.com/SheafofPlanes.html
   """
   __sigs__=[[Real._Sphere,Real._PlaneArray]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return CirclePencil(t[0],t[1],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #21
0
def zPointArray(*args,**kws):
   """
:constructors: 

   - zPointArray(zcircle);              calls: `class zCirclePoints`_
   - zPointArray(zline);                calls: `class zLinePoints`_
   
:returns: An instance of an object derived from the `_zPointArray`_ abstract class,
          representing an array of points with determined positions 
          on the `complex plane`_
   """
   __sigs__=[[Complex._zCircle]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return zCirclePoints(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #22
0
def zLine(*args, **kws):
    """
:constructors: 

   - zLine(zpoint1,zpoint2); calls: `class zLinefromPoints`_
   - zLine(zcircle1,zcircle2); calls: `class zBiChord`_
   
:returns: the line_ of the `complex plane`_ uniquely determined by its arguments
   """
    __sigs__ = [[Complex._zPoint, Complex._zPoint], [Complex._zCircle, Complex._zCircle]]
    t, i = method_get(__sigs__, args)
    if t is None:
        raise Argument_Type_Error(__sigs__, args)
    else:
        if i == 0:
            return zLineFromPoints(t[0], t[1], **kws)
        elif i == 1:
            return zBiChord(t[0], t[1], **kws)
        else:
            raise Argument_Type_Error(__sigs__, args)
Example #23
0
def zSlider(*args,**kws):
   """
:constructors: 

   - zSlider(line, <ratio = numeric> ); calls: `class zLineSlider`_
   - zSlider(circle, <angle = numeric>); calls: `class zCircleSlider`_
  
:returns: A point_ that is pickable, with movement constrained with reference 
          to a given geometric object of the `complex plnae`_
   """

   __sigs__ = [[Complex._zCircle],[Complex._zLine]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i == 0:
         return zCircleSlider(t[0],**kws)
      elif i == 1:
         return zLineSlider(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #24
0
def  uTransform(*args,**kws):
   """
:constructors: 

  - uTransform(<list of objects of the zplane>);  calls: `class uStereoProject`_
  
:returns: `stereographic projection`_ of given objects of the `complex plane`_ to the 
          `Riemann sphere`_  
    
:site ref: http://en.wikipedia.org/wiki/User:Pmurray_bigpond.com/Complex_Numbers_as_a_3_Vector
   """
   __sigs__=[[list]]
   
   t,i = method_get(__sigs__,args)

   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return uStereoProject(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #25
0
def AniPoint(*args,**kws):
   """
:constructors:


  - AniPoint(circle,<rate=integer>,<angle=numeric>); calls `class CirclingPoint`_
  - AniPoint(line, <rate=integer>,<ratio=numeric>); calls `class CirclingPoint`_

:returns: a point which moves constrained to a given geometric object at each
          display update cycle.
   """
   __sigs__ = [[Real._Circle],[Real._Line]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i == 0:
         return CirclingPoint(t[0],**kws)
      elif i == 1:
         return SlidingPoint(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #26
0
def uAniPoint(*args,**kws):
   """
:constructors: 

  - uAniPoint(<theta=numeric>, <phi=numeric>, <rate=integer>);  calls: `class uSpiral`_
  - uAniPoint(ucircle,<angle=nmeric>,<rate=integer> );  calls: `class uCirclingPoint`_
  
:returns: A point of the `Riemann sphere`_ that moves at each 
          update cycle, constrained as determined by its arguments.
   """
   __sigs__=[[],
             [USphere._uCircle]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return uSpiral(**kws)
      elif i==1:
         return uCirclingPoint(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #27
0
def Divider(*args,**kws):
   """
:constructors:

    - Divider(line, ratio_ =.4); calls:  `class LineDivider`
    - Divider(line,point1, point2); calls: `class LineCut`_
    - Divider(line1,line2); calls: `class LineCut`_
    - Divider(p1_a,p1_b,p1_c,p1_d,p1a,p2_a,p2_b,p2_c); calls: class CrossPoint`_
    - Divider(point1, point2, point3);calls: `class Harmonic`_

:returns:   a point_ which divides a geometric object
   """
   __sigs__ = [[Real._Line],[Real._Line,float],[Real._Line,vector,vector],
               [Real._Line,Real._Line],
               [vector, vector,vector],
               [list,list],   
               [Real._Circle]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
     if i == 0:
         return LineDivider(t[0],**kws)
     elif i == 1:
         return LineDivider(t[0],t[1],**kws)
     elif i == 2:
         return LineCut(t[0],t[1],t[2],**kws)
     elif i == 3:
         return LineCut(t[0],t[1].p1,t[1].p2,**kws)
     elif i == 4:
         return Harmonic(t[0],t[1],t[2],**kws)
     elif i == 5:
          if (len(t[0])==4 and len(t[1])==3):
              return CrossPoint(t[0],t[1],**kws)
     elif i == 6:
         return CircumPoint(t[0],**kws)
     else:
         raise Argument_Type_Error(__sigs__,args)
Example #28
0
def Foot(*args,**kws):
   """
:constructors:

   - Foot(line, point): calls: `class LineFoot`_
   - Foot(plane,point); calls: `class PlaneFoot`_

:returns: A point at the foot_ of a given point_
          with respect to a given geometric object

:site ref: http://mathworld.wolfram.com/PerpendicularFoot.html
   """
   __sigs__ = [[Real._Plane,vector],[Real._Line,vector]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
     if i == 0:
        return PlaneFoot(t[0],t[1],**kws)
     elif i == 1:
        return LineFoot(t[0],t[1],**kws)
     else:
        raise Argument_Type_Error(__sigs__,args)
Example #29
0
def uCirclePencil(*args,**kws):
   """
:constructors: 

  - uCirclePencil(planearray);  calls: `class uSphereSlices`_
  - uCircle(zCirclePencil);  calls: `class z_to_uCirclePencil`_
  
:returns: an array of `_uCircle`_ s
          
:site ref: http://mathworld.wolfram.com/SphericSection.html
   """
   __sigs__=[[Real._PlaneArray],
            [Complex._zCirclePencil]]
   t,i = method_get(__sigs__,args)
   if t is None:
      raise Argument_Type_Error(__sigs__,args)
   else:
      if i==0:
         return uSphereSlices(t[0],**kws)
      elif i==1:
         return z_to_uCirclePencil(t[0],**kws)
      else:
         raise Argument_Type_Error(__sigs__,args)
Example #30
0
def Reflection(*args,**kws):
   """
:constructors:

   -  Reflection(point,line); calls:  `class LineReflection`_
   -  Reflection(point, plane); calls:  `class PlaneReflection`_

:returns:   A point_ instance determined as the `reflection`_ of a given
            point_ with respect to a given geometric object

:site ref: http://mathworld.wolfram.com/Reflection.html
   """
   __sigs__=[[vector, Real._Plane],[vector,Real._Line]]
   t,i=method_get(__sigs__,args)
   if t is  None:
     raise Argument_Type_Error(__sigs__,args)
   else:
     if i==0:
        return PlaneReflection(t[0],t[1],**kws)
     elif i==1:
        return LineReflection(t[0],t[1],**kws)
     else:
        raise Argument_Type_Error(__sigs__,args)