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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)