Exploring Analyic Geometry with Mathematica®

Home Contents Commands Packages Explorations Reference
Tour Lines Circles Conics Analysis Tangents

Command Browser

This chapter is an alphabetical listing of all the commands provided by Descarta2D.  The syntax and usage of each command is described, as well as notes outlining special options and defaults.  Additionally, a cross-reference pointing to related commands is provided in each section.  Commands described as being low-level are used in the internal implementation of Descarta2D.  Low-level commands may be used freely, but they are not generally mentioned in the subject matter chapters of the book.

Angle2D Foci2D Line2D Segment2D
Apex2D Hyperbola2D Loci2D SegmentArea2D
Arc2D Inscribed2D MakePrimitives2D SemiConjugateAxis2D
ArcLength2D Is2D MaxSeconds2D SemiMajorAxis2D
Area2D IsApproximate2D MedialEquations2D SemiMinorAxis2D
AskCurveLength2D IsCoincident2D MedialLoci2D SemiTransverseAxis2D
Asymptotes2D IsCollinear2D ObjectNames2D SetDisplay2D
Bulge2D IsComplex2D Parabola2D SimplifyCoefficients2D
Centroid2D IsConcentric2D Parallel2D Sketch2D
ChopImaginary2D IsConcurrent2D Parameters2D Slope2D
Circle2D IsDisplay2D Pencil2D Solve2D
Circumference2D IsNegative2D Perimeter2D SolveTriangle2D
Circumscribed2D IsNumeric2D Perpendicular2D Span2D
Complement2D IsOn2D Point2D TangentCircles2D
ConicArc2D IsParallel2D Points2D TangentConics2D
Conjugate2D IsPerpendicular2D Polynomial2D TangentEquation2D
Coordinates2D IsReal2D PrimaryAngle2D TangentLines2D
CurveLength2D IsScalar2D PrimaryAngleRange2D TangentPoints2D
CurveLimits2D IsScalarPair2D Quadratic2D TangentQuadratics2D
Directrices2D IsTangent2D Radius2D TangentSegments2D
Distance2D IsTinyImaginary2D Reflect2D Translate2D
Eccentricity2D IsTripleParallel2D ReflectAngle2D Triangle2D
Ellipse2D IsValid2D Rho2D Vertices2D
Equation2D IsZero2D Rotate2D XCoordinate2D
FocalChords2D IsZeroOrNegative2D Scale2D YCoordinate2D
FocalLength2D Length2D SectorArea2D

Angle2D [Top]

Angle2D[line] computes the angle a line makes with the +x-axis, when measured counter-clockwise from the +x-axis to the line.

• Angles in Descarta2D are always specified and returned in radians.

Angle2D[arc] computes the angular span of an arc.

Angle2D[arc,t] computes the angle a radial diameter passing through the point at parameter t on the arc makes with the +x-axis.

Angle2D[conic] returns the rotation angle of a conic curve.  The conic may be an ellipse, hyperbola or parabola.

Angle2D[line,line] computes the angle measured counter-clockwise from the first line to the second line.    

Angle2D[triangle,n] computes the vertex angle at vertex n of a triangle.

• See also: PrimaryAngle2D, PrimaryAngleRange2D, ReflectAngle2D.

Apex2D [Top]

Apex2D is a keyword indicating the construction of the apex control point of a conic arc.

• See also: Point2D.

Arc2D [Top]

Arc2D[{"browser_1.gif","browser_2.gif"},{"browser_3.gif","browser_4.gif"},B] is the standard representation of an arc.  The coordinates of the start point are "browser_5.gif" and the coordinates of the end point are "browser_6.gif".  The bulge factor is the positive number B.  The arc is traversed counter-clockwise from the start point to the end point.

• The bulge factor, B, is the ratio of the arc's height, h, to half the chord length, d/2; so B=2h/d.

Arc2D[{"browser_7.gif","browser_8.gif"},{"browser_9.gif","browser_10.gif"},B][t] and arc[t] return the {x,y} coordinates of a point at parameter t on an arc.  Parameter values in the range 0≤t≤1 produce coordinates covering the complete span of the arc.

Arc2D[{"browser_11.gif","browser_12.gif"},{"browser_13.gif","browser_14.gif"},B][{"browser_15.gif","browser_16.gif"}] produces graphics primitives for a portion of an arc between parameters "browser_17.gif" and "browser_18.gif" when plotted.

Arc2D[arc,Complement2D] constructs the complement of an arc.

Arc2D[point,r,{"browser_19.gif","browser_20.gif"}] constructs an arc from the center point, radius and span.  The angles, "browser_21.gif" and "browser_22.gif", are measured counter-clockwise from the +x-axis.

Arc2D[point,r,{"browser_23.gif","browser_24.gif"}] constructs an arc from the center point, radius and the start and end points of the span.  The start/end points do not need to lie on the arc, although they cannot be coincident with the center.

Arc2D[point,point,point] constructs an arc passing through three points.  The first and third points define the span of the arc.

Arc2D[{point,θ},point] constructs an arc from a start point with entry angle and an end point.

• See also: Bulge2D, Complement2D.

ArcLength2D [Top]

ArcLength2D[curve,{"browser_25.gif","browser_26.gif"}] computes the arc length of a curve between two parameter values.

• The curve may be an arc, circle, ellipse, hyperbola, line, line segment or parabola.

N[ArcLength2D[cnarc,{"browser_27.gif","browser_28.gif"}]] numerically computes the arc length of a conic arc between two parameter values.

• See also: Circumference2D, Length2D, Perimeter2D, Span2D.

Area2D [Top]

Area2D[curve] computes the area associated with a curve.

• The curve may be an arc, circle, conic arc, ellipse or triangle.

Area2D[arc] computes the area between an arc and its chord.

Area2D[circle] computes the area of a circle.

Area2D[cnarc] computes the area between a conic arc and its chord.

Area2D[ellipse] computes the area of an ellipse.

Area2D[triangle] computes the area of a triangle.

• See also: SectorArea2D, SegmentArea2D.

AskCurveLength2D [Top]

AskCurveLength2D[] is a low-level function that returns the value of the CurveLength2D option of the Sketch2D command.

• See also: CurveLength2D, Sketch2D.

Asymptotes2D [Top]

Asymptotes2D[hyperbola] constructs a list containing the two asymptote lines of a hyperbola.

Bulge2D [Top]

Bulge2D[arc] returns the bulge factor of an arc.

• See also: Arc2D.

Centroid2D [Top]

Centroid2D is a keyword indicating the construction of a triangle's centroid point.

• See also: Point2D.

ChopImaginary2D [Top]

ChopImaginary2D[expr,tol] is a low-level function that removes insignificant imaginary parts of complex numbers in an expression.  The imaginary part is considered insignificant if its absolute value is less than the tolerance.

• The tolerance, if omitted, defaults to "browser_29.gif".

Circle2D [Top]

Circle2D[{h,k},r] is the standard representation of a circle.  The coordinates of the center point of the circle are {h,k} and the radius is r.

Circle2D[{h,k},r}][θ] and circle[θ] return the {x,y} coordinates of a point at parameter θ on a circle.  Parameter values in the range 0≤θ<2π produce coordinates covering the complete circumference of the circle.

Circle2D[{h,k},r}][{"browser_30.gif","browser_31.gif"}] produces graphics primitives for the arc of the circle between parameters "browser_32.gif" and "browser_33.gif" when plotted.

Circle2D[arc] constructs the circle underlying an arc.

Circle2D[circle,circle,k,Pencil2D] constructs a circle, parameterized by the variable k, that represents the family (pencil) of circles passing through the intersection points of the two given circles.  The family of circles is valid even if the two circles do not intersect as they will share a common radical axis.

Circle2D[lnseg] constructs the circle whose diameter chord is a given line segment.

Circle2D[point,r] constructs the circle centered at a point with a given radius.

Circle2D[point,point] constructs the circle given a center point and a point on the circle.

Circle2D[point,point,point] constructs a circle through three points.

Circle2D[point,line] constructs a circle with a given center point and tangent to a line.

Circle2D[quad] constructs the circle associated with a quadratic.

Circle2D[triangle,Circumscribed2D] constructs a circle circumscribed about a triangle.

Circle2D[triangle,Inscribed2D] constructs a circle inscribed inside a triangle.

• See also: Inscribed2D, Circumscribed2D, Pencil2D, TangentCircles2D.

Circumference2D [Top]

Circumference2D[circle] computes the circumference of a circle.

Circumference2D[ellipse] computes the circumference of an ellipse.

• See also: ArcLength2D.

Circumscribed2D [Top]

Circumscribed2D is a keyword indicating a construction involving a triangle's circumscribed circle.

• See also: Circle2D, Point2D.

Complement2D [Top]

Complement2D is a keyword indicating the construction of an arc's complement.

• See also: Arc2D.

ConicArc2D [Top]

ConicArc2D[{"browser_34.gif","browser_35.gif"},{"browser_36.gif","browser_37.gif"},{"browser_38.gif","browser_39.gif"},ρ] is the standard representation of a conic arc.  The coordinates of the start point are {"browser_40.gif","browser_41.gif"}, the coordinates of the apex point are {"browser_42.gif","browser_43.gif"} and the coordinates of the end point are {"browser_44.gif","browser_45.gif"}.  The projective discriminant is ρ.

ConicArc2D[{"browser_46.gif","browser_47.gif"},{"browser_48.gif","browser_49.gif"},{"browser_50.gif","browser_51.gif"},ρ][t] and cnarc[t] return the {x,y} coordinates of a point at parameter t on a conic arc.  Parameter values in the range 0≤t≤1 produce coordinates covering the entire length of the conic arc.

ConicArc2D[{"browser_52.gif","browser_53.gif"},{"browser_54.gif","browser_55.gif"},{"browser_56.gif","browser_57.gif"},ρ][{"browser_58.gif","browser_59.gif"}] produces graphics primitives representing the portion of the conic arc between parameters "browser_60.gif" and "browser_61.gif" when plotted.

ConicArc2D[line,conic] constructs a conic arc defined by a conic (circle, ellipse, hyperbola or parabola) and a line containing the conic arc's chord.

Conjugate2D [Top]

Conjugate2D is a keyword indicating the construction of a conjugate hyperbola.

• See also: Hyperbola2D.

Coordinates2D [Top]

Coordinates2D[args..] returns the {x,y} coordinates of the point that would be returned by the function Point2D[args..].

• See also: Point2D, XCoordinate2D, YCoordinate2D.

CurveLength2D [Top]

CurveLength2D is an option for the Sketch2D command specifying the approximate length that an unbounded curve should be rendered when plotted.

• The initial default, if not specified, is 10.  The default can by changed using the Mathematica SetOptions command.

• See also: AskCurveLength2D, Sketch2D.

CurveLimits2D [Top]

CurveLimits2D[coords,curve] is a low-level function that computes a list of two parameter values on a curve such that the point whose coordinates are given is a distance CurveLength2D/2 from the points on the curve at the parameter values.

• See also: AskCurveLength2D, CurveLength2D, Sketch2D.

Directrices2D [Top]

Directrices2D[conic] returns a list of the directrix line(s) of a conic curve.

• The conic may be an ellipse, hyperbola or parabola.  If the conic is an ellipse or hyperbola there are two directrix lines in the list; if the conic is a parabola there is one directrix line in the list.

Distance2D [Top]

Distance2D[coords,coords] computes the distance between two positions given by coordinates.

Distance2D[point,point] computes the distance between two points.

Distance2D[point,line] computes the distance between a point and a line.

Distance2D[point,circle] computes the distance between a point and a circle.

Eccentricity2D [Top]

Eccentricity2D[conic] computes the eccentricity of a conic.

• The conic may be a ellipse, hyperbola or parabola.

Ellipse2D [Top]

Ellipse2D[{h,k},a,b,θ] is the standard representation of an ellipse.  The coordinates of the center point are {h,k}, the length of the semi-major axis is a, the length of the semi-minor axis is b and the angle of rotation, counter-clockwise with respect to the +x-axis, is θ.

"browser_62.gif"] and ellipse["browser_63.gif"] return the {x,y} coordinates of a point at parameter "browser_64.gif" on an ellipse.  Parameter values in the range "browser_65.gif" produce coordinates covering the complete circumference of the ellipse.

Ellipse2D[{h,k},a,b,θ][{"browser_66.gif","browser_67.gif"}] produces graphics primitives on the portion of the ellipse between parameter values "browser_68.gif" and "browser_69.gif" when plotted.

Ellipse2D[point,line,e] constructs an ellipse defined by a focus point, directrix line and eccentricity.

Ellipse2D[point,point,e] constructs an ellipse from two focus points and the eccentricity.

Ellipse2D[{point,point},e] constructs an ellipse from two vertex points and the eccentricity.

Equation2D [Top]

Equation2D[line,{x,y}] returns the equation A x+B y+C==0, which is the equation of the line.

Equation2D[quad,{x,y}] returns "browser_70.gif"which is the equation of the quadratic.

• See also: Polynomial2D.

FocalChords2D [Top]

FocalChords2D[conic] returns a list containing the focal chords of a conic curve (line segments).

• The conic may be an ellipse, hyperbola or parabola.  If the conic is an ellipse or hyperbola the list contains two focal chords (line segments); if the conic is a parabola the list contains a single focal chord (line segment).

FocalLength2D [Top]

FocalLength2D[parabola] returns the focal length of a parabola.

• See also: Parabola2D.

Foci2D [Top]

Foci2D[conic] returns a list containing the focus point(s) of a conic.

• The conic may be an ellipse, hyperbola or parabola.  If the conic is an ellipse or hyperbola the list contains two focus points; if the conic is a parabola the list contains a single focus point.

Hyperbola2D [Top]

Hyperbola2D[{h,k},a,b,θ] is the standard representation of a hyperbola.  The coordinates of the center point are {h,k}, the length of the semi-transverse axis is a, the length of the semi-conjugate axis is b and the angle of rotation, counter-clockwise with respect to the +x-axis, is θ.

Hyperbola2D[{h,k},a,b,θ][t] and hyperbola[t] return the {x,y} coordinates of a point at parameter t on the primary branch of a hyperbola.  Parameter values in the range -∞<t<+∞ cover the complete hyperbola branch.  The primary branch opens about the +x-axis when the angle of rotation is zero.

Hyperbola2D[{h,k},a,b,θ,True][t] returns the {x,y} coordinates of a point at parameter t on the non-primary (reflected) branch of a hyperbola (used only for graphics rendering).

Hyperbola2D[{h,k},a,b,θ][{"browser_71.gif","browser_72.gif"}] produces graphics primitives for a portion of the hyperbola between parameters values "browser_73.gif" and "browser_74.gif" when plotting.  If "browser_75.gif" the parameters represent a portion of the primary branch of the hyperbola; if "browser_76.gif" the parameters represent a portion of the other branch.

Hyperbola2D[hyperbola,Conjugate2D] constructs the conjugate of a hyperbola.

Hyperbola2D[point,line,e] constructs a hyperbola defined by a focus point, directrix line and eccentricity.

Hyperbola2D[point,point,e] constructs a hyperbola from two focus points and the eccentricity.

Hyperbola2D[{point,point},e] constructs a hyperbola from two vertex points and the eccentricity.

• See also: Conjugate2D.

Inscribed2D [Top]

Inscribed2D is a keyword indicating a construction involving a triangle's inscribed circle.

• See also: Circle2D, Point2D.

Is2D [Top]

Is2D[object,objHeadList] is a low-level function that returns True if the object is a valid Descarta2D object and its head is included in the head list; otherwise, returns False.

IsApproximate2D [Top]

IsApproximate2D[expr] is a low-level function that returns True if the expression contains approximate real numbers; otherwise, returns False.

• The function will attempt to detect if the pending evaluation will eventually be approximated using the N[expr] function.  If this condition is detected the function will also return True.

IsCoincident2D [Top]

IsCoincident2D[obj,obj] returns True if two objects are of the same type and are coincident; otherwise, returns False.  The objects may be circles, coordinates, lines, points or quadratics.

• The function returns unevaluated if the two objects are of a different type.

IsCoincident2D[objList] returns True if any pair of objects in a list are of the same type and are coincident; otherwise, returns False.

IsCollinear2D [Top]

IsCollinear2D[point,point,point] returns True if three points are collinear; otherwise, returns False.

IsCollinear2D[ptList] returns True if any triple of points in a list is collinear; otherwise, returns False.

IsComplex2D [Top]

IsComplex2D[expr,tol] is a low-level function that returns True if the expression, when evaluated, contains a complex number (a number is considered complex if the absolute value of its imaginary part is greater than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_77.gif".

IsComplex2D[exprList,tol] returns True if any expression in a list, when evaluated, contains a complex number; otherwise, returns False.

IsComplex2D[exprList,Or,tol] returns True if any expression in a list, when evaluated, contains a complex number; otherwise, returns False.

IsComplex2D[exprList,And,tol] returns True if all the expressions in a list, when evaluated, contain complex numbers; otherwise, returns False.

IsConcentric2D [Top]

IsConcentric2D[cirle,circle] returns True if two circles are concentric; otherwise, returns False.

IsConcentric2D[cirList] returns True if any pair of circles in a list are concentric; otherwise, returns False.

IsConcurrent2D [Top]

IsConcurrent2D[line,line,line] returns True if three lines are concurrent (intersect in a common point); otherwise, returns False.

IsConcurrent2D[lnList] returns True if any triple of lines in a list is concurrent; otherwise, returns False.

IsDisplay2D [Top]

IsDisplay2D[object] is a low-level function that returns True if the object is a displayable Descarta2D object; otherwise, returns False.

IsNegative2D [Top]

IsNegative2D[expr,tol] is a low-level function that returns True if the expression, when evaluated, is negative (a number is considered negative if it is less than zero and its absolute value is greater than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_78.gif".

IsNegative2D[exprList,tol] returns True if any expression in a list, when evaluated, is negative; otherwise, returns False.

IsNegative2D[exprList,Or,tol] returns True if any expression in a list, when evaluated, is negative; otherwise, returns False.

IsNegative2D[exprList,And,tol] returns True if all the expressions in a list, when evaluated, are negative; otherwise, returns False.

• See also: IsZero2D, IsZeroOrNegative2D.

IsNumeric2D [Top]

IsNumeric2D[expr,tol] is a low-level function that returns True if all the atoms in an expression can be evaluated to real numbers (a complex number is considered real if the absolute value of its imaginary part is less than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_79.gif".

IsNumeric2D[expr,funcName,tol] returns True if all the atoms in an expression can be evaluated to real numbers; otherwise, returns False and displays a message stating that the function, funcName, requires numerical arguments.  This form is a low-level function and is intended to be used for argument checking.

IsOn2D [Top]

IsOn2D[point,curve] returns True if a point is on a curve; otherwise, returns False.

• The curve may be a line, circle or quadratic.

IsOn2D[point,Quadratic2D[conic]] returns True if a point is on a conic; otherwise, returns False.  The conic may be a circle, ellipse, hyperbola or parabola.

IsParallel2D [Top]

IsParallel2D[line,line] returns True if two lines are parallel; otherwise, returns False.

IsParallel2D[lnList] returns True if any pair of lines in a list is parallel; otherwise, returns False.

• See also: IsTripleParallel2D.

IsPerpendicular2D [Top]

IsPerpendicular2D[line,line] returns True if two lines are perpendicular; otherwise, returns False.

IsPerpendicular2D[lnList] returns True if any pair of lines in a list is perpendicular; otherwise, returns False.

IsReal2D [Top]

IsReal2D[expr,tol] is a low-level function that returns True if the expression, when evaluated, is a real number (a complex number is considered real if the absolute value of its imaginary part is less than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_80.gif".

IsScalar2D [Top]

IsScalar2D[expr] is a low-level function that returns True if the expression appears to be a scalar quantity—that is, it cannot be recognized as a list, a complex number or a Descarta2D object; otherwise, returns False.

• This function is used by Descarta2D for argument checking.

• See also: IsScalarPair2D.

IsScalarPair2D [Top]

IsScalarPair2D[{expr,expr}] is a low-level function that returns True if both expressions appear to be scalar quantities—that is, they cannot be recognized as lists, complex numbers or Descarta2D objects; otherwise, returns False.

• This function is used by Descarta2D for argument checking.

• See also: IsScalar2D.

IsTangent2D [Top]

IsTangent2D[line,circle] returns True if a line is tangent to a circle; otherwise, returns False.

IsTangent2D[line,quad] returns True if a line is tangent to a quadratic; otherwise, returns False.

IsTangent2D[line,Quadratic2D[conic]] returns True if a line is tangent to a conic; otherwise, returns False.  The conic may be a circle, ellipse, hyperbola or parabola.

IsTangent2D[circle,circle] returns True if two circles are tangent to each other; otherwise, returns False.

IsTinyImaginary2D [Top]

IsTinyImaginary2D[expr,tol] is a low-level function that returns True if any complex number in an expression has a tiny imaginary part (the imaginary part is considered tiny if its absolute value is less than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_81.gif".

IsTripleParallel2D [Top]

IsTripleParallel2D[line,line,line] returns True if three lines are mutually parallel; otherwise, returns False.

IsTripleParallel2D[lnList] returns True if any triple of lines in a list is mutually parallel; otherwise, returns False.

• See also: IsParallel2D.

IsValid2D [Top]

IsValid2D[object] is a low-level function that returns True if the object is syntactically valid; otherwise, returns False.

• The object may be an arc, circle, conic arc, ellipse, hyperbola, line, line segment, parabola, point, quadratic or triangle.

IsZero2D [Top]

IsZero2D[expr,tol] is a low-level function that returns True if the expression, when evaluated, is zero (a number is considered zero if its absolute value is less than the tolerance); otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_82.gif".

IsZero2D[exprList,tol] returns True if any expression in a list, when evaluated, is zero; otherwise, returns False.

IsZero2D[exprList,Or,tol] returns True if any expression in a list, when evaluated, is zero; otherwise, returns False.

IsZero2D[exprList,And,tol] returns True if all the expressions in a list, when evaluated, are zero; otherwise, returns False.

• See also: IsNegative2D, IsZeroOrNegative2D.

IsZeroOrNegative2D [Top]

IsZeroOrNegative2D[expr,tol] returns True if the expression, when evaluated, is zero or negative; otherwise, returns False.

• The tolerance, if omitted, defaults to "browser_83.gif".

IsZeroOrNegative2D[exprList,tol] returns True if any expression in a list, when evaluated, is zero or negative; otherwise, returns False.

IsZeroOrNegative2D[exprList,Or,tol] returns True if any expression in a list, when evaluated, is zero or negative; otherwise, returns False.

IsZeroOrNegative2D[exprList,And,tol] returns True if all the expressions in a list, when evaluated, are zero or negative; otherwise, returns False.

• See also: IsNegative2D, IsZero2D.

Length2D [Top]

Length2D[lnseg] computes the length of a line segment.

• See also: ArcLength2D.

Line2D [Top]

Line2D[A,B,C] is the standard representation of the line A x+B y+C=0.

Line2D[A,B,C][t] and line[t] return the {x,y} coordinates of a point at parameter t on a line.  Parameter values in the range -∞<t<+∞ produce coordinates covering the complete line.

Line2D[A,B,C][{"browser_84.gif","browser_85.gif"}] produces graphics primitives for the line segment between parameters "browser_86.gif" and "browser_87.gif" when plotting.

Line2D[circle,circle] constructs the radical axis line of two circles.

Line2D[coords,coords] constructs a line through two positions specified by {x,y} coordinates.

Line2D[ellipse] constructs a line which contains the major axis of an ellipse.

Line2D[eqn,{x,y}] constructs a line from the equation A x+B y+C==0.

Line2D[hyperbola] constructs a line which contains the transverse axis of a hyperbola.

Line2D[line] constructs a line with normalized coefficients.

Line2D[line,d] constructs a line offset a distance d from a given line.  The distance may be positive or negative producing one of two possible offsets.

Line2D[line,line,k,Pencil2D] constructs a family of lines (pencil), parameterized by k, passing through the intersection point of two given lines.

Line2D[lnseg] constructs a line containing a line segment.

Line2D[lnseg,Perpendicular2D] constructs a line that is the perpendicular bisector of a line segment.

Line2D[parabola] constructs a line which contains the axis of a parabola.

Line2D[point,curve] constructs the polar (line) of a curve given the pole (point).  If the pole (point) is on the curve, then the polar (line) is the tangent to the curve at the pole (point).  The curve may be a circle, ellipse, hyperbola, parabola or quadratic.

Line2D[point,k,Pencil2D] constructs a family of lines (pencil), parameterized by k, passing through a point.

Line2D[point,line] constructs a line through a point perpendicular to a line.

Line2D[point,line,Perpendicular2D] also constructs a line through a point perpendicular to a line.

Line2D[point,line,Parallel2D] constructs a line through a point parallel to a line.

Line2D[point,m] constructs a line with slope m passing through a point.

Line2D[point,Infinity] constructs a vertical line through a point.

Line2D[point,point] constructs a line through two points.

Line2D[point,point,Perpendicular2D] constructs a line equidistant from two points.  This line is the perpendicular bisector of the line segment defined by the two points.

Line2D[poly,{x,y}] constructs a line from the polynomial A x+B y+C.

Line2D[triangle,"browser_88.gif","browser_89.gif"] constructs a line containing vertices "browser_90.gif" and "browser_91.gif" of a triangle.

• See also: Parallel2D, Pencil2D, Perpendicular2D.

Loci2D [Top]

Loci2D[quad] returns a list of objects represented by a quadratic.  The list may contain a conic, one or two lines, a point or it may be empty.

Loci2D[cnarc] returns a list containing the curve underlying a conic arc.

Loci2D[point,length,e] returns a list containing the conic defined by the vertex equation parameters.  The point is the vertex point, the length is the focal length and the constant, e, is the eccentricity.  The conic is constructed in standard position.

Loci2D[point,length,e,θ] returns a list containing the conic defined by the vertex equation parameters.  The point is the vertex point, the length is the focal length, the constant, e, is the eccentricity and θ is the angle of rotation.

Loci2D[point,line,e] returns a list containing the conic defined by a focus point, directrix line and eccentricity.

MakePrimitives2D [Top]

MakePrimitives2D[curve,{"browser_92.gif","browser_93.gif"}] is a low-level function that returns a list of Mathematica graphics primitives approximating a curve between two parameter values.

• The curve may be an arc, circle, conic arc, ellipse, hyperbola, line, line segment or parabola.

MaxSeconds2D [Top]

MaxSeconds2D is a keyword indicating the maximum number of seconds allowed for solving equations.

• See also: Solve2D.

MedialEquations2D [Top]

MedialEquations2D[{obj,obj}] returns a list of lines or quadratics equidistant from two given objects.  The given objects may be points, lines or circles.

• See also: MedialLoci2D.

MedialLoci2D [Top]

MedialLoci2D[{obj,obj}] returns a list of objects equidistant from two given objects.  The given objects may be points, lines or circles.

• See also: MedialEquations2D.

ObjectNames2D [Top]

ObjectNames2D[] returns a list of strings which are the names of all the Descarta2D objects.

Parabola2D [Top]

Parabola2D[{h,k},f,θ] is the standard representation of a parabola.  The coordinates of the vertex point are {h,k}, the focal length is f and the angle of rotation, counter-clockwise with respect to the +x-axis, is θ.

Parabola2D[{h,k},f,θ][t] and parabola[t] return the {x,y} coordinates of a point at parameter t on a parabola.  Parameter values in the range -∞<t<+∞ produce coordinates covering the complete parabola.

Parabola2D[{h,k},f,θ][{"browser_94.gif","browser_95.gif"}] produces graphics primitives for the portion of the parabola between parameters "browser_96.gif" and "browser_97.gif" when plotting.

Parabola2D[point,line] constructs a parabola defined by a focus point and a directrix line.

Parallel2D [Top]

Parallel2D is a keyword indicating a parallel construction.

• See also: Line2D, TangentLines2D.

Parameters2D [Top]

Parameters2D[line,curve] computes a list of the two parameters where a line intersects a curve.

• The curve may be a circle, ellipse, hyperbola or parabola.  The list of parameters is useful for computing areas and arc lengths defined by the line and the curve.

• See also: ArcLength2D, SectorArea2D, SegmentArea2D.

Pencil2D [Top]

Pencil2D is a keyword indicating the construction of a pencil of curves.

• See also: Line2D, Circle2D, Quadratic2D.

Perimeter2D [Top]

Perimeter2D[triangle] computes the perimeter of a triangle.

• See also: ArcLength2D.

Perpendicular2D [Top]

Perpendicular2D is a keyword indicating a perpendicular construction.

• See also: Line2D, TangentLines2D.

Point2D [Top]

Point2D[{x, y}] or Point2D[coords] is the standard representation of a point with coordinates {x, y}.

Point2D[x,y] constructs a point at coordinates (x,y).

Point2D[arc] constructs the center point of an arc.

Point2D[circle] constructs the center point of a circle.

Point2D[cnarc] constructs the center point of the conic underlying a conic arc.

Point2D[cnarc,Apex2D] constructs the apex control point of a conic arc.

Point2D[conic] constructs the center point of a central conic.  The conic may be a circle, ellipse or hyperbola.

Point2D[curve[t]] constructs a point at a parameter value on a curve.

Point2D[line,curve] constructs the pole (point) of a curve given the polar (line).  If the polar (line) is tangent to the curve, then the pole (point) is the point of tangency.  The curve may be a circle, ellipse, hyperbola, parabola or quadratic.

Point2D[line,line] constructs the intersection point of two lines.

Point2D[lnseg] constructs the midpoint of a line segment.

Point2D[parabola] constructs the vertex point of a parabola.

Point2D[point,line] constructs a point by projecting a point onto a line.

Point2D[point,line,d] constructs a point by offsetting a point a distance, d, in the direction of a line.  The distance may be positive or negative resulting in one of two possible offset points.

Point2D[point,line,{u,v}] constructs the point with coordinates {u,v} in the coordinate system defined by a point and a line.  The line defines the y-axis and the point is on the +x-axis.

Point2D[point,point] constructs the midpoint of two points.

Point2D[point,point,d] constructs a point by offsetting a point a distance, d, in the direction of a second point.  If the distance is negative, the point is offset in the opposite direction.

Point2D[point,point,"browser_98.gif","browser_99.gif"] constructs a point dividing the segment between two points into the ratio "browser_100.gif".

Point2D[quad] constructs the center point of a quadratic, assuming the quadratic is a central conic.

Point2D[triangle,Centroid2D] constructs a point at the centroid of a triangle.

Point2D[triangle,Circumscribed2D] constructs the center point of a circle circumscribed about a triangle.

Point2D[triangle,Inscribed2D] constructs the center point of a circle inscribed inside a triangle.

Point2D[triangle,n] constructs a point at vertex n of a triangle.

• See also: Apex2D, Centroid2D, Circumscribed2D, Inscribed2D.

Points2D [Top]

Points2D[curve,curve] constructs a list containing the intersection points of two curves.

• The curves may be lines, circles, ellipses, hyperbolas, parabolas or quadratics.

Polynomial2D [Top]

Polynomial2D[line,{x,y}] returns the polynomial A x+B y+C, which is the polynomial of the line.

Polynomial2D[quad,{x,y}] returns "browser_101.gif"which is the polynomial of the quadratic.

• See also: Equation2D.

PrimaryAngle2D [Top]

PrimaryAngle2D[θ] returns a primary angle in the range 0≤φ<2π where φ=Mod[θ, ].

PrimaryAngle2D[θ, ] returns a primary angle in the range 0≤φ<2π where φ is given by Mod[θ, ].

PrimaryAngle2D[θ, π] returns a primary angle in the range 0≤φ<π where φ is given by Mod[θ, π].

• See also: PrimaryAngleRange2D.

PrimaryAngleRange2D [Top]

PrimaryAngleRange2D[{"browser_102.gif", "browser_103.gif"}] returns a list of two primary angles, {"browser_104.gif","browser_105.gif"}, such that "browser_106.gif" and "browser_107.gif".

PrimaryAngleRange2D[arc] returns a list of two primary angles, {"browser_108.gif","browser_109.gif"}, which are the spanning angles of the arc.

• See also: PrimaryAngle2D.

Quadratic2D [Top]

Quadratic2D[A,B,C,D,E,F] is the standard representation of the quadratic given by "browser_110.gif".

Quadratic2D[cnarc] constructs the quadratic underlying a conic arc.

Quadratic2D[conic] constructs the quadratic associated with a conic.  The conic may be a circle, ellipse, hyperbola or parabola.

Quadratic2D[coords] constructs the quadratic representing a position specified by coordinates (a circle of zero radius).

Quadratic2D[eqn,{x,y}] constructs a quadratic from an equation given in the form  "browser_111.gif"

Quadratic2D[line,line] constructs the quadratic representing the product of two lines.

Quadratic2D[{line,line},{line,line},k,Pencil2D] constructs a family of quadratics, parameterized by k, passing through the intersection points of four lines taken in pairs.

Quadratic2D[line,line,line,line,line] constructs the quadratic tangent to five lines.

Quadratic2D[point] constructs the quadratic representing a point (a circle of zero radius).

Quadratic2D[point,length,e] constructs the quadratic defined by the vertex equation parameters.  The point is the vertex point, the length is the focal length and the constant, e, is the eccentricity.  The quadratic is constructed in standard position.

Quadratic2D[point,length,e,θ] constructs the quadratic defined by the vertex equation parameters.  The point is the vertex point, the length is the focal length, the constant, e, is the eccentricity and θ is the angle of rotation.

Quadratic2D[point,line,e] constructs the quadratic defined by a focus point, directrix line and eccentricity.

Quadratic2D[point,point,point] constructs the quadratic representing the circle passing through three points.

Quadratic2D[point,point,point,point,k,Pencil2D] constructs a family of quadratics, parameterized by k, passing through four points.

Quadratic2D[point,point,point,point,point] constructs a quadratic passing through five points.

Quadratic2D[poly,{x,y}] constructs a quadratic from the polynomial given in the form "browser_112.gif"

Quadratic2D[quad] constructs a quadratic with normalized coefficients.

Quadratic2D[quad,quad,k,Pencil2D] constructs a family (pencil) of quadratics, parameterized by k, and passing through the intersection points of two quadratics.

• See also: Pencil2D.

Radius2D [Top]

Radius2D[circle] returns the radius of a circle.

Radius2D[arc] returns the radius of an arc.

• See also: Arc2D, Circle2D.

Reflect2D [Top]

Reflect2D[object, line] reflects an object in a line.

• The object may be an arc, circle, conic arc, coordinates, ellipse, hyperbola, line, line segment, parabola, point or triangle.

Reflect2D[objList, line] reflects a list of objects in a line, returning a list of objects.

Reflect2D[eqn,{x,y},line] reflects an equation in a line.

• The equation may be linear, A x+B y+C==0, or quadratic, "browser_113.gif"

• See also: ReflectAngle2D, Rotate2D, Scale2D, Translate2D.

ReflectAngle2D [Top]

ReflectAngle2D[θ, line] computes the reflection of an angle in a line.

• If a line L makes an angle θ with the +x-axis and line L' is the reflection of L in the given line (the second argument to the function), then the function computes the angle θ' that L' makes with the +x-axis.

• See also: Reflect2D.

Rho2D [Top]

Rho2D[cnarc] returns the projective discriminant of a conic arc.

• See also: ConicArc2D.

Rotate2D [Top]

Rotate2D[object,θ,coords] rotates an object by an angle θ (in radians) about a position whose coordinates are given.  If the coordinates are omitted, the default is the origin.

• The object may be an arc, circle, conic arc, coordinates, ellipse, hyperbola, line, line segment, parabola or triangle.

Rotate2D[objList,θ,coords] rotates a list of objects.

Rotate2D[eqn,{x,y},θ,coords] rotates an equation by an angle θ (in radians) about a position whose coordinates are given.

• The equation may be linear, A x+B y+C==0, or quadratic, "browser_114.gif"

• See also: Reflect2D, Scale2D, Translate2D.

Scale2D [Top]

Scale2D[object,s,coords] scales an object from a position given as coordinates.  If the coordinates are omitted, the default is the origin.

• The object may be an arc, circle, conic arc, coordinates, ellipse, hyperbola, line, line segment, parabola or triangle.

Scale2D[objList,s,coords] scales a list of objects from a position whose coordinates are given.

Scale2D[eqn,{x,y},s,coords] scales an equation from a position.

• The equation may be linear, A x+B y+C==0, or quadratic, "browser_115.gif".

• See also: Reflect2D, Rotate2D, Translate2D.

SectorArea2D [Top]

SectorArea2D[curve,{"browser_116.gif","browser_117.gif"}] computes the area of a sector of a curve between two parameters.

• The curve may be a circle, ellipse or hyperbola (the sector is defined from the center point of the curve to the two points defined by the parameters on the curve).

• See also: Area2D, SegmentArea2D.

Segment2D [Top]

Segment2D[{"browser_118.gif","browser_119.gif"},{"browser_120.gif","browser_121.gif"}] is the standard representation of a line segment.  The coordinates of the start point are {"browser_122.gif","browser_123.gif"} and the coordinates of the end point are {"browser_124.gif","browser_125.gif"}.

Segment2D[{"browser_126.gif","browser_127.gif"},{"browser_128.gif","browser_129.gif"][t] and lnseg[t] return the {x,y} coordinates of a point at parameter t on a line segment.  Parameter values in the range 0≤t≤1 produce coordinates covering the entire length of the line segment.

Segment2D[{"browser_130.gif","browser_131.gif"},{"browser_132.gif","browser_133.gif"][{"browser_134.gif","browser_135.gif"}] produces graphics primitives for the line segment between parameters "browser_136.gif" and "browser_137.gif" when plotting.

Segment2D[point,point] constructs a line segment between two points.

Segment2D[triangle,"browser_138.gif","browser_139.gif"] constructs a line segment between vertices "browser_140.gif" and "browser_141.gif" of a triangle.

SegmentArea2D [Top]

SegmentArea2D[curve,{"browser_142.gif","browser_143.gif"}] computes the area of a segment of a curve between two parameters.

• The curve may be a circle, ellipse, hyperbola or parabola (the segment is the area between the curve and the chord defined by the two parameters).

• See also: Area2D, SectorArea2D.

SemiConjugateAxis2D [Top]

SemiConjugateAxis2D[hyperbola] returns the length of the semi-conjugate axis of a hyperbola.

• See also: Hyperbola2D, SemiTransverseAxis2D.

SemiMajorAxis2D [Top]

SemiMajorAxis2D[ellipse] returns the length of the semi-major axis of an ellipse.

• See also: Ellipse2D, SemiMinorAxis2D.

SemiMinorAxis2D [Top]

SemiMinorAxis2D[ellipse] returns the length of the semi-minor axis of an ellipse.

• See also: Ellipse2D, SemiMajorAxis2D.

SemiTransverseAxis2D [Top]

SemiTransverseAxis2D[hyperbola] returns the length of the semi-transverse axis of a hyperbola.

• See also: Hyperbola2D, SemiConjugateAxis2D.

SetDisplay2D [Top]

SetDisplay2D[objPatt,objPrim] is a low-level function that specifies the graphics primitives to use when plotting a given object pattern.

SimplifyCoefficients2D [Top]

SimplifyCoefficients2D[coefList] is a low-level function that returns a list of coefficients with common factors removed.

Simplify[line] and FullSimplify[line] use SimplifyCoefficients2D to simplify the coefficients of a line.

Simplify[quad] and FullSimplify[quad] use SimplifyCoefficients2D to simplify the coefficients of a quadratic.

Sketch2D [Top]

Sketch2D[objList,opts] produces a plot of the objects in a list.

• The list of objects may be nested.  Any of the options for the Mathematica Graphics command may be specified.

Sketch2D[objList,CurveLength2D->n,opts] produces a plot of the objects in a list, using a specified curve length for unbounded curves.

• See also: AskCurveLength2D, CurveLength2D.

Slope2D [Top]

Slope2D[line] computes the slope of a line.

Slope2D[lnseg] computes the slope of a line segment.

Solve2D [Top]

Solve2D[eqnList,varList] is a low-level function that solves a list of equations for a list of variables and returns a list of rules representing the solutions.

Solve2D[eqnList,varList,MaxSeconds2D->n] solves a list of equations for a list of variables with a time limit of n seconds.

• See also: MaxSeconds2D.

SolveTriangle2D [Top]

SolveTriangle2D[{{"browser_144.gif","browser_145.gif","browser_146.gif"},{"browser_147.gif","browser_148.gif","browser_149.gif"}}] computes a triangle configuration from three sides and/or angles.  Unspecified arguments should be Null.

SolveTriangle2D[{{"browser_150.gif","browser_151.gif","browser_152.gif"},{"browser_153.gif","browser_154.gif","browser_155.gif"},True}] computes a triangle configuration from three sides and/or angles, returning an alternate solution, if one exists.

• The configuration is returned in the form {{"browser_156.gif","browser_157.gif","browser_158.gif"},{"browser_159.gif","browser_160.gif","browser_161.gif"}}.

• See also: Triangle2D.

Span2D [Top]

Span2D[arc] computes the arc length of the complete span of an arc.

N[Span2D[cnarc]] numerically computes the arc length of the complete span of a conic arc.

• See also: ArcLength2D.

TangentCircles2D [Top]

TangentCircles2D[{pt|ln|cir,pt|ln|cir,pt|ln|cir}] constructs a list of circles tangent to three objects (points, lines or circles).

• For brevity of expression a circle is said to be tangent to a point if the point is on the circle.

TangentCircles2D[{pt|ln|cir},pt] constructs a list of circles tangent to an object (point, line or circle) with a given center point.

TangentCircles2D[{pt|ln|cir},ln|cir,r] constructs a list of circles tangent to an object (point, line or circle), whose center is on a line or circle, with a given radius.

TangentCircles2D[{pt|ln|cir,pt|ln|cir},r] constructs a list of circles tangent to two objects (points, lines or circles), with a given radius.

TangentCircles2D[{pt|ln|cir,pt|ln|cir},ln|cir] constructs a list of circles tangent to two objects (points, lines or circles), with center on a given line or circle.

• See also: Circle2D.

TangentConics2D [Top]

TangentConics2D[{pt|ln,pt|ln,pt|ln,pt|ln,pt|ln}] constructs a list of conics tangent to five objects (points or lines).

• The expressions in the resulting conics can be very complicated and are usually practical only if evaluated numerically.

• See also: TangentQuadratics2D.

TangentEquation2D [Top]

TangentEquation2D[line,quad] returns an equation involving the coefficients of a line and a quadratic that constrains the two curves to be tangent.

TangentLines2D [Top]

TangentLines2D[curve,curve] constructs a list of lines tangent to two curves.

• The curves may be circles, ellipses, hyperbolas, parabolas or quadratics.

TangentLines2D[line,curve] constructs a list of lines parallel to a line and tangent to a curve.

TangentLines2D[line,curve,Parallel2D] also constructs a list of lines parallel to a line and tangent to a curve.

TangentLines2D[line,curve,Perpendicular2D] also constructs a list of lines perpendicular to a line and tangent to a curve.

TangentLines2D[point,curve] constructs a list of lines from a point and tangent to a curve.

• See also: Parallel2D, Perpendicular2D, TangentSegments2D.

TangentPoints2D [Top]

TangentPoints2D[point,curve] constructs a list of points that are the points of tangency of lines from a point to a curve.

• The curve may be a circle, ellipse, hyperbola, parabola or quadratic.

TangentQuadratics2D [Top]

TangentQuadratics2D[{pt|ln,pt|ln,pt|ln,pt|ln,pt|ln}] constructs a list of quadratics tangent to five objects (points or lines).

• The expressions in the resulting quadratics can be very complicated and are usually practical only if evaluated numerically.

• See also: TangentConics2D.

TangentSegments2D [Top]

TangentSegments2D[curve,curve] constructs a list of line segments tangent to two curves.

• The curves may be circles, ellipses, hyperbolas, parabolas or quadratics.

• See also: TangentLines2D.

Translate2D [Top]

Translate2D[object,{u,v}] translates an object delta distance.

• The object may be an arc, circle, conic arc, coordinates, ellipse, hyperbola, line, line segment, parabola, quadratic or triangle.

Translate2D[objList,{u,v}] translates a list of objects.

Translate2D[eqn,{x,y},{u,v}] translates an equation delta distance.

• The equation may be linear, A x+B y+C==0, or quadratic, "browser_162.gif"

• See also: Reflect2D, Rotate2D, Scale2D.

Triangle2D [Top]

Triangle2D[{"browser_163.gif","browser_164.gif"},{"browser_165.gif","browser_166.gif"},{"browser_167.gif","browser_168.gif"}] is the standard representation of a triangle defined by three vertex coordinates.

Triangle2D[{"browser_169.gif","browser_170.gif","browser_171.gif"}] constructs a triangle from three side lengths. The first vertex of the triangle will be the origin and the second vertex will be on the +x-axis.

Triangle2D[{{"browser_172.gif","browser_173.gif","browser_174.gif"},{"browser_175.gif","browser_176.gif","browser_177.gif"}}] constructs a triangle from three sides and/or angles.  Unspecified arguments should be Null. The first vertex of the triangle will be the origin and the second vertex will be on the +x-axis.

Triangle2D[{{"browser_178.gif","browser_179.gif","browser_180.gif"},{"browser_181.gif","browser_182.gif","browser_183.gif"},True}] constructs a triangle from three sides and/or angles, returning an alternate solution, if one exists.

Triangle2D[line,line,line] constructs a triangle whose sides are specified by three lines.

Triangle2D[point,point,point] constructs a triangle whose vertices are specified by three points.

• See also: SolveTriangle2D.

Vertices2D [Top]

Vertices2D[conic] returns a list containing the vertex point(s) of a conic curve.

• The conic may be an ellipse, hyperbola or parabola.  If the conic is an ellipse or hyperbola the list contains two vertex points; if the conic is a parabola the list contains a single vertex point.

XCoordinate2D [Top]

XCoordinate2D[point] returns the x-coordinate of a point.

XCoordinate2D[coords] returns the x-coordinate of a location.

• See also: Coordinates2D, Point2D, YCoordinate2D.

YCoordinate2D [Top]

YCoordinate2D[point] returns the y-coordinate of a point.

YCoordinate2D[coords] returns the y-coordinate of a location.

• See also: Coordinates2D, Point2D, XCoordinate2D.


Copyright © 1999-2007 Donald L. Vossler, Descarta2D Publishing
www.Descarta2D.com