Retour à la page ASYMPTOTE du site gmaths.net.
Retour au forum ASYMPTOTE.

Asymptote : index des fonctions

Mise à jour le 8/05/2014 à partir de la version 2.27

Cette page se veut être une interface de lecture du fichier asy.list de la version SVN d'Asymptote (avec ses défauts : les types en reviennent aux fondamentaux, sans prendre en compte les typedef des fichiers asy.

Par exemple, au lieu d'y trouver le type transform3, on y lira real[][].).

Cible de la recherche Texte à filtrer Expression régulière Smart filter
Filtre global
Filtre sur le TYPE
Filtre sur le NOM
Filtre sur les ARGUMENTS
Type Nom Arguments
abscissa angabscissa (arc a, point M);
abscissa angabscissa (circle c, point M);
abscissa angabscissa (ellipse el, point M, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
abscissa angabscissa (explicit conic co, point M);
abscissa angabscissa (hyperbola h, point M, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
abscissa angabscissa (int x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
abscissa angabscissa (parabola p, point M);
abscissa angabscissa (real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
abscissa curabscissa (arc a, point M);
abscissa curabscissa (circle c, point M);
abscissa curabscissa (conic co, point M);
abscissa curabscissa (ellipse el, point M);
abscissa curabscissa (int x);
abscissa curabscissa (line l, point M);
abscissa curabscissa (parabola p, point M);
abscissa curabscissa (real x);
abscissa nodabscissa (arc a, point M);
abscissa nodabscissa (circle c, point M);
abscissa nodabscissa (conic co, point M);
abscissa nodabscissa (ellipse el, point M);
abscissa nodabscissa (int x);
abscissa nodabscissa (line l, point M);
abscissa nodabscissa (parabola p, point M);
abscissa nodabscissa (real x);
abscissa operator * (explicit abscissa a, real x);
abscissa operator * (real x, explicit abscissa a);
abscissa operator + (explicit abscissa a, real x);
abscissa operator + (int x, explicit abscissa a);
abscissa operator + (real x, explicit abscissa a);
abscissa operator - (explicit abscissa a);
abscissa operator - (explicit abscissa a, real x);
abscissa operator - (int x, explicit abscissa a);
abscissa operator - (real x, explicit abscissa a);
abscissa operator / (explicit abscissa a, real x);
abscissa operator / (int x, explicit abscissa a);
abscissa operator / (real x, explicit abscissa a);
abscissa operator cast (explicit position position);
abscissa operator cast (int x);
abscissa operator cast (real x);
abscissa operator init ();
abscissa relabscissa (arc a, point M);
abscissa relabscissa (circle c, point M);
abscissa relabscissa (conic co, point M);
abscissa relabscissa (ellipse el, point M);
abscissa relabscissa (int x);
abscissa relabscissa (line l, point M);
abscissa relabscissa (real x);
align NoAlign;
align operator cast (pair dir);
align operator cast (side side);
align operator cast (triple dir);
align operator cast (vector v);
align operator init ();
animation operator init ();
arc arc (ellipse el, explicit abscissa x1, explicit abscissa x2, bool direction=<default>);
arc arc (ellipse el, point M, point N, bool direction=<default>);
arc arc (ellipse el, real angle1, real angle2, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>, bool direction=<default>);
arc arc (explicit arc a, abscissa x1, abscissa x2);
arc arc (explicit arc a, point M, point N);
arc arccircle (point A, point B, real angle, bool direction=<default>);
arc arccircle (point A, point M, point B);
arc arcsubtended (point A, point B, real angle);
arc complementary (arc a);
arc inverse (real k, point A, segment s);
arc operator * (int x, explicit arc a);
arc operator * (inversion i, segment s);
arc operator * (real x, explicit arc a);
arc operator * (transform t, explicit arc a);
arc operator + (explicit arc a, point M);
arc operator + (explicit arc a, vector v);
arc operator - (explicit arc a, point M);
arc operator - (explicit arc a, vector v);
arc operator / (explicit arc a, real x);
arc operator init ();
arc reverse (arc a);
arrowhead DefaultHead;
arrowhead HookHead (real dir=<default>, real barb=<default>);
arrowhead HookHead;
arrowhead operator init ();
arrowhead SimpleHead;
arrowhead TeXHead;
autoscaleT defaultS;
autoscaleT operator init ();
axisT axis;
axisT operator init ();
binarytree binarytree (... key[] keys);
binarytree operator init ();
binarytree searchtree (... int[] keys);
binarytreeNode binarytreeNode (int key);
binarytreeNode operator init ();
block bevel (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dh=<default>, real dw=<default>, real minwidth=<default>, real minheight=<default>);
block blockconnector (block, block)(picture pic, transform t, pen p=<default>, marginT margin(path, pen)=<default>);
block circle (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dr=<default>, real mindiameter=<default>);
block diamond (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real ds=<default>, real dw=<default>, real height=<default>, real minwidth=<default>, real minheight=<default>);
block operator -- (block b, bool arrowbar(picture, path, pen, marginT(path, pen)));
block operator -- (block b1, Dir dir);
block operator -- (block b1, Label label);
block operator init ();
block parallelogram (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dx=<default>, real slope=<default>, real minwidth=<default>, real minheight=<default>);
block rectangle (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dx=<default>, real minwidth=<default>, real minheight=<default>);
block rectangle (object header, object body, pair center=<default>, pen headerpen=<default>, pen bodypen=<default>, pen drawpen=<default>, real dx=<default>, real minheaderwidth=<default>, real minheaderheight=<default>, real minbodywidth=<default>, real minbodyheight=<default>);
block roundrectangle (object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real ds=<default>, real dw=<default>, real minwidth=<default>, real minheight=<default>);
bool adjust (pen p);
bool alias (align a, align b);
bool alias (arrowhead a, arrowhead b);
bool alias (autoscaleT a, autoscaleT b);
bool alias (bool3 a, bool3 b);
bool alias (bool3[] a, bool3[] b);
bool alias (bool[] a, bool[] b);
bool alias (bounds a, bounds b);
bool alias (coord a, coord b);
bool alias (coord a, coord b);
bool alias (coords2 a, coords2 b);
bool alias (coords2 a, coords2 b);
bool alias (coords3 a, coords3 b);
bool alias (coord[] a, coord[] b);
bool alias (coord[] a, coord[] b);
bool alias (cputime a, cputime b);
bool alias (filltype a, filltype b);
bool alias (framedTransformStack a, framedTransformStack b);
bool alias (frame[] a, frame[] b);
bool alias (freezableBounds a, freezableBounds b);
bool alias (guide[] a, guide[] b);
bool alias (hsv a, hsv b);
bool alias (indexedTransform a, indexedTransform b);
bool alias (int[] a, int[] b);
bool alias (Label a, Label b);
bool alias (Label[] a, Label[] b);
bool alias (Legend a, Legend b);
bool alias (Legend[] a, Legend[] b);
bool alias (light a, light b);
bool alias (marginT a, marginT b);
bool alias (marker a, marker b);
bool alias (marker[] a, marker[] b);
bool alias (object a, object b);
bool alias (object[] a, object[] b);
bool alias (pairOrTriple a, pairOrTriple b);
bool alias (pair[] a, pair[] b);
bool alias (pair[][] a, pair[][] b);
bool alias (path[] a, path[] b);
bool alias (pen[] a, pen[] b);
bool alias (pen[][] a, pen[][] b);
bool alias (picture a, picture b);
bool alias (picture[] a, picture[] b);
bool alias (position a, position b);
bool alias (processtime a, processtime b);
bool alias (projection a, projection b);
bool alias (real[] a, real[] b);
bool alias (real[][] a, real[][] b);
bool alias (scaleT a, scaleT b);
bool alias (ScaleT a, ScaleT b);
bool alias (scaling a, scaling b);
bool alias (scaling a, scaling b);
bool alias (side a, side b);
bool alias (slice a, slice b);
bool alias (string[] a, string[] b);
bool alias (string[][] a, string[][] b);
bool alias (transformation a, transformation b);
bool alias (triple[] a, triple[] b);
bool alias (void()()[] a, void()()[] b);
bool all (bool[] a);
bool allowstepping;
bool appendsuffix;
bool ArcArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool ArcArrow (picture, path, pen, marginT(path, pen));
bool ArcArrows (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
bool ArcArrows (picture, path, pen, marginT(path, pen));
bool Arrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool Arrow (picture, path, pen, marginT(path, pen));
bool Arrows (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
bool Arrows (picture, path, pen, marginT(path, pen));
bool Aspect;
bool axiscoverage (int N, transform T, path g, ticklocate locate, real Step, pair side, int sign, real Size, Label F, string ticklabel(real), real norm, real limit);
bool Bar (picture, path, pen, marginT(path, pen))(real size=<default>);
bool Bar (picture, path, pen, marginT(path, pen));
bool Bars (picture, path, pen, marginT(path, pen))(real size=<default>);
bool Bars (picture, path, pen, marginT(path, pen));
bool BeginArcArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool BeginArcArrow (picture, path, pen, marginT(path, pen));
bool BeginArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool BeginArrow (picture, path, pen, marginT(path, pen));
bool BeginBar (picture, path, pen, marginT(path, pen))(real size=<default>);
bool BeginBar (picture, path, pen, marginT(path, pen));
bool between (point M, point O, point N);
bool Blank (picture, path, pen, marginT(path, pen));
bool byfoci;
bool byvertices;
bool CCW;
bool checkposition ();
bool checkSegment (path g, pair p, pair q);
bool collinear (vector u, vector v);
bool concurrent (... line[] l);
bool contains (tree t, int key);
bool Crop;
bool currentarrow (picture, path, pen, marginT(path, pen));
bool currentmomarrow (picture, path, pen, marginT(path, pen));
bool CW;
bool cyclic (guide g);
bool cyclic (path p);
bool cyclic (path3 p);
bool debugging;
bool defined (point P);
bool degenerate (circle c);
bool degenerate (conic c);
bool degenerate (ellipse el);
bool diagnostics;
bool empty ();
bool empty (frame f);
bool EndArcArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool EndArcArrow (picture, path, pen, marginT(path, pen));
bool EndArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
bool EndArrow (picture, path, pen, marginT(path, pen));
bool EndBar (picture, path, pen, marginT(path, pen))(real size=<default>);
bool EndBar (picture, path, pen, marginT(path, pen));
bool eof (file f);
bool eol (file f);
bool error (file f);
bool finite (explicit point p);
bool finite (pair z);
bool finite (real x);
bool finite (triple v);
bool firststep;
bool havepagenumber;
bool ignore;
bool IgnoreAspect;
bool increasing (real[] a, bool strict=<default>);
bool inside (ellipse el, point M);
bool inside (explicit path[] g, pair z, pen fillrule=<default>);
bool inside (parabola p, point M);
bool inside (path g, pair z, pen fillrule=<default>);
bool interactive ();
bool interior (int windingnumber, pen fillrule);
bool invisible (pen p);
bool inXasyMode;
bool is3D (frame f);
bool is3D (string format=<default>);
bool isDuplicate (pair a, pair b, real relSize);
bool isnan (real x);
bool isparabola (bqe bqe);
bool itemstep;
bool labels (frame f);
bool landscape;
bool latex ();
bool lexorder (pair a, pair b);
bool lexorder (triple a, triple b);
bool logaxiscoverage (int N, transform T, path g, ticklocate locate, pair side, int sign, real Size, Label F, string ticklabel(real), real limit, int first, int last);
bool MidArcArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
bool MidArcArrow (picture, path, pen, marginT(path, pen));
bool MidArrow (picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
bool MidArrow (picture, path, pen, marginT(path, pen));
bool needshipout ();
bool NoCrop;
bool None (picture, path, pen, marginT(path, pen));
bool onpath (picture pic=<default>, path g, point M, pen p=<default>);
bool operator ! (bool b);
bool operator != (align a, align b);
bool operator != (arrowhead a, arrowhead b);
bool operator != (autoscaleT a, autoscaleT b);
bool operator != (bool a, bool b);
bool operator != (bool a, bool3 b);
bool operator != (bool3 a, bool b);
bool operator != (bool3 a, bool3 b);
bool operator != (bool[][] a, bool[][] b);
bool operator != (bounds a, bounds b);
bool operator != (coord a, coord b);
bool operator != (coord a, coord b);
bool operator != (coords2 a, coords2 b);
bool operator != (coords2 a, coords2 b);
bool operator != (coords3 a, coords3 b);
bool operator != (cputime a, cputime b);
bool operator != (explicit point M, explicit point N);
bool operator != (file a, file b);
bool operator != (filltype a, filltype b);
bool operator != (framedTransformStack a, framedTransformStack b);
bool operator != (freezableBounds a, freezableBounds b);
bool operator != (hsv a, hsv b);
bool operator != (indexedTransform a, indexedTransform b);
bool operator != (int a, int b);
bool operator != (int[][] a, int[][] b);
bool operator != (Label a, Label b);
bool operator != (Legend a, Legend b);
bool operator != (light a, light b);
bool operator != (line l1, line l2);
bool operator != (marginT a, marginT b);
bool operator != (marker a, marker b);
bool operator != (object a, object b);
bool operator != (pair a, pair b);
bool operator != (pairOrTriple a, pairOrTriple b);
bool operator != (pair[][] a, pair[][] b);
bool operator != (path a, path b);
bool operator != (path3 a, path3 b);
bool operator != (pen a, pen b);
bool operator != (picture a, picture b);
bool operator != (position a, position b);
bool operator != (processtime a, processtime b);
bool operator != (projection a, projection b);
bool operator != (real a, real b);
bool operator != (real[][] a, real[][] b);
bool operator != (ScaleT a, ScaleT b);
bool operator != (scaleT a, scaleT b);
bool operator != (scaling a, scaling b);
bool operator != (scaling a, scaling b);
bool operator != (side a, side b);
bool operator != (slice a, slice b);
bool operator != (string a, string b);
bool operator != (string[][] a, string[][] b);
bool operator != (transform a, transform b);
bool operator != (transformation a, transformation b);
bool operator != (triple a, triple b);
bool operator != (triple[][] a, triple[][] b);
bool operator & (bool a, bool b);
bool operator > (int a, int b);
bool operator > (real a, real b);
bool operator > (string a, string b);
bool operator >= (coord a, coord b);
bool operator >= (coord a, coord b);
bool operator >= (int a, int b);
bool operator >= (real a, real b);
bool operator >= (string a, string b);
bool operator < (int a, int b);
bool operator < (real a, real b);
bool operator < (string a, string b);
bool operator <= (coord a, coord b);
bool operator <= (coord a, coord b);
bool operator <= (int a, int b);
bool operator <= (real a, real b);
bool operator <= (string a, string b);
bool operator == (align a, align b);
bool operator == (arrowhead a, arrowhead b);
bool operator == (autoscaleT a, autoscaleT b);
bool operator == (bool a, bool b);
bool operator == (bool a, bool3 b);
bool operator == (bool3 a, bool b);
bool operator == (bool3 a, bool3 b);
bool operator == (bool[][] a, bool[][] b);
bool operator == (bounds a, bounds b);
bool operator == (coord a, coord b);
bool operator == (coord a, coord b);
bool operator == (coords2 a, coords2 b);
bool operator == (coords2 a, coords2 b);
bool operator == (coords3 a, coords3 b);
bool operator == (coordsys c1, coordsys c2);
bool operator == (cputime a, cputime b);
bool operator == (explicit point M, explicit point N);
bool operator == (explicit vector u, explicit vector v);
bool operator == (file a, file b);
bool operator == (filltype a, filltype b);
bool operator == (framedTransformStack a, framedTransformStack b);
bool operator == (freezableBounds a, freezableBounds b);
bool operator == (hsv a, hsv b);
bool operator == (indexedTransform a, indexedTransform b);
bool operator == (int a, int b);
bool operator == (int[][] a, int[][] b);
bool operator == (Label a, Label b);
bool operator == (Legend a, Legend b);
bool operator == (light a, light b);
bool operator == (line l1, line l2);
bool operator == (marginT a, marginT b);
bool operator == (marker a, marker b);
bool operator == (object a, object b);
bool operator == (pair a, pair b);
bool operator == (pairOrTriple a, pairOrTriple b);
bool operator == (pair[][] a, pair[][] b);
bool operator == (path a, path b);
bool operator == (path3 a, path3 b);
bool operator == (pen a, pen b);
bool operator == (picture a, picture b);
bool operator == (position a, position b);
bool operator == (processtime a, processtime b);
bool operator == (projection a, projection b);
bool operator == (real a, real b);
bool operator == (real[][] a, real[][] b);
bool operator == (ScaleT a, ScaleT b);
bool operator == (scaleT a, scaleT b);
bool operator == (scaling a, scaling b);
bool operator == (scaling a, scaling b);
bool operator == (side a, side b);
bool operator == (slice a, slice b);
bool operator == (string a, string b);
bool operator == (string[][] a, string[][] b);
bool operator == (transform a, transform b);
bool operator == (transformation a, transformation b);
bool operator == (triple a, triple b);
bool operator == (triple[][] a, triple[][] b);
bool operator @ (point M, arc a);
bool operator @ (point M, conic co);
bool operator @ (point M, explicit circle c);
bool operator @ (point m, line l);
bool operator cast (bool3 b);
bool operator cast (file);
bool operator init ();
bool operator ^ (bool a, bool b);
bool operator | (bool a, bool b);
bool overpaint;
bool parallel (line l1, line l2, bool strictly=<default>);
bool pdf ();
bool perpendicular (line l1, line l2);
bool piecewisestraight (path p);
bool piecewisestraight (path3 p);
bool polygon (path p);
bool prc (string format=<default>);
bool prc0 (string format=<default>);
bool prconly (string format=<default>);
bool rectangular (pair[][] m);
bool rectangular (real[][] m);
bool rectangular (triple[][] m);
bool reverse;
bool samecoordsys (bool warn=<default> ... bqe[] bqes);
bool samecoordsys (bool warn=<default> ... point[] M);
bool sameside (point M, point N, point O);
bool sameside (point M, point P, line l);
bool scale (pen p);
bool shipped;
bool simeq (point A, point B, real fuzz=<default>);
bool simeq (point a, real b, real fuzz=<default>);
bool square (real[][] m);
bool stepping;
bool straight (path p, int t);
bool straight (path3 p, int t);
bool uperiodic (triple[][] a);
bool uptodate ();
bool view ();
bool vperiodic (triple[][] a);
bool XYAlign;
bool YAlign;
bool3 default;
bool3 operator cast (bool b);
bool3 operator init ();
bool3[] array (int n, bool3 value, int depth=<default>);
bool3[] concat (... bool3[][]);
bool3[] copy (bool3[] a, int depth=<default>);
bool3[] map (bool3 f(bool3), bool3[] a);
bool3[] operator cast (bool[] b);
bool3[] sequence (bool3 f(int), int n);
bool3[] sort (bool3[] a, bool less(bool3, bool3));
bool[] array (int n, bool value, int depth=<default>);
bool[] concat (... bool[][]);
bool[] copy (bool[] a, int depth=<default>);
bool[] map (bool f(bool), bool[] a);
bool[] operator ! (bool[] a);
bool[] operator != (bool a, bool[] b);
bool[] operator != (bool[] a, bool b);
bool[] operator != (bool[] a, bool[] b);
bool[] operator != (int a, int[] b);
bool[] operator != (int[] a, int b);
bool[] operator != (int[] a, int[] b);
bool[] operator != (pair a, pair[] b);
bool[] operator != (pair[] a, pair b);
bool[] operator != (pair[] a, pair[] b);
bool[] operator != (pen[] a, pen[] b);
bool[] operator != (real a, real[] b);
bool[] operator != (real[] a, real b);
bool[] operator != (real[] a, real[] b);
bool[] operator != (string a, string[] b);
bool[] operator != (string[] a, string b);
bool[] operator != (string[] a, string[] b);
bool[] operator != (triple a, triple[] b);
bool[] operator != (triple[] a, triple b);
bool[] operator != (triple[] a, triple[] b);
bool[] operator & (bool a, bool[] b);
bool[] operator & (bool[] a, bool b);
bool[] operator & (bool[] a, bool[] b);
bool[] operator > (int a, int[] b);
bool[] operator > (int[] a, int b);
bool[] operator > (int[] a, int[] b);
bool[] operator > (real a, real[] b);
bool[] operator > (real[] a, real b);
bool[] operator > (real[] a, real[] b);
bool[] operator > (string a, string[] b);
bool[] operator > (string[] a, string b);
bool[] operator > (string[] a, string[] b);
bool[] operator >= (int a, int[] b);
bool[] operator >= (int[] a, int b);
bool[] operator >= (int[] a, int[] b);
bool[] operator >= (real a, real[] b);
bool[] operator >= (real[] a, real b);
bool[] operator >= (real[] a, real[] b);
bool[] operator >= (string a, string[] b);
bool[] operator >= (string[] a, string b);
bool[] operator >= (string[] a, string[] b);
bool[] operator < (int a, int[] b);
bool[] operator < (int[] a, int b);
bool[] operator < (int[] a, int[] b);
bool[] operator < (real a, real[] b);
bool[] operator < (real[] a, real b);
bool[] operator < (real[] a, real[] b);
bool[] operator < (string a, string[] b);
bool[] operator < (string[] a, string b);
bool[] operator < (string[] a, string[] b);
bool[] operator <= (int a, int[] b);
bool[] operator <= (int[] a, int b);
bool[] operator <= (int[] a, int[] b);
bool[] operator <= (real a, real[] b);
bool[] operator <= (real[] a, real b);
bool[] operator <= (real[] a, real[] b);
bool[] operator <= (string a, string[] b);
bool[] operator <= (string[] a, string b);
bool[] operator <= (string[] a, string[] b);
bool[] operator == (bool a, bool[] b);
bool[] operator == (bool[] a, bool b);
bool[] operator == (bool[] a, bool[] b);
bool[] operator == (int a, int[] b);
bool[] operator == (int[] a, int b);
bool[] operator == (int[] a, int[] b);
bool[] operator == (pair a, pair[] b);
bool[] operator == (pair[] a, pair b);
bool[] operator == (pair[] a, pair[] b);
bool[] operator == (pen[] a, pen[] b);
bool[] operator == (real a, real[] b);
bool[] operator == (real[] a, real b);
bool[] operator == (real[] a, real[] b);
bool[] operator == (string a, string[] b);
bool[] operator == (string[] a, string b);
bool[] operator == (string[] a, string[] b);
bool[] operator == (triple a, triple[] b);
bool[] operator == (triple[] a, triple b);
bool[] operator == (triple[] a, triple[] b);
bool[] operator cast (bool3[] b);
bool[] operator cast (file);
bool[] operator ^ (bool a, bool[] b);
bool[] operator ^ (bool[] a, bool b);
bool[] operator ^ (bool[] a, bool[] b);
bool[] operator | (bool a, bool[] b);
bool[] operator | (bool[] a, bool b);
bool[] operator | (bool[] a, bool[] b);
bool[] reverse (bool[] a);
bool[] sequence (bool f(int), int n);
bool[] sort (bool[] a, bool less(bool, bool));
bool[][] operator cast (file);
bool[][][] operator cast (file);
bounds Automatic (picture pic, real min, real max);
bounds autoscale (real Min, real Max, scaleT scale=<default>);
bounds Full (picture pic, real min, real max);
bounds image (picture pic=<default>, pair[] z, real[] f, bounds range(picture pic, real min, real max)=<default>, pen[] palette);
bounds image (picture pic=<default>, real f(real, real), bounds range(picture pic, real min, real max)=<default>, pair initial, pair final, int nx=<default>, int ny=<default>, pen[] palette, bool antialias=<default>);
bounds image (picture pic=<default>, real[] x, real[] y, real[] f, bounds range(picture pic, real min, real max)=<default>, pen[] palette);
bounds image (picture pic=<default>, real[][] f, bounds range(picture pic, real min, real max)=<default>, pair initial, pair final, pen[] palette, bool transpose=<default>, bool copy=<default>, bool antialias=<default>);
bounds operator * (transform t, bounds b);
bounds operator init ();
bounds operator init ();
bounds Range (picture pic, real min, real max)(bool automin=<default>, real min=<default>, bool automax=<default>, real max=<default>);
bqe bqe (coordsys R=<default>, real a, real b, real c, real d, real e, real f);
bqe bqe (point M1, point M2, point M3, point M4, point M5);
bqe canonical (bqe bqe);
bqe changecoordsys (coordsys R, bqe bqe);
bqe equation (ellipse el);
bqe equation (explicit conic co);
bqe equation (hyperbola h);
bqe equation (parabola p);
bqe operator init ();
Braid apply (Relation r, Braid b, int step, int place);
Braid operator init ();
bsp operator init ();
bucket operator init ();
circle circle (explicit point C, real r);
circle circle (inversion i);
circle circle (point A, point B);
circle circle (point A, point B, point C);
circle circle (segment s);
circle circle (triangle t);
circle circumcircle (point A, point B, point C);
circle circumcircle (triangle t);
circle excircle (point A, point B, point C);
circle excircle (side side);
circle incircle (point A, point B, point C);
circle incircle (triangle t);
circle inverse (real k, point A, circle c);
circle inverse (real k, point A, line l);
circle operator * (int x, explicit circle c);
circle operator * (inversion i, circle c);
circle operator * (inversion i, line l);
circle operator * (real x, explicit circle c);
circle operator + (explicit circle c, explicit point M);
circle operator + (explicit circle c, pair m);
circle operator + (explicit circle c, vector m);
circle operator - (explicit circle c, explicit point M);
circle operator - (explicit circle c, pair m);
circle operator - (explicit circle c, vector m);
circle operator / (explicit circle c, int x);
circle operator / (explicit circle c, real x);
circle operator cast (conic c);
circle operator cast (ellipse el);
circle operator cast (inversion i);
circle operator init ();
coefficients operator init ();
coloredpath operator cast (guide p);
coloredpath operator cast (path p);
coloredpath operator init ();
Component bm;
Component bp;
Component operator init ();
Component phi;
Component wye;
conic changecoordsys (coordsys R, conic co);
conic conic (bqe bqe);
conic conic (point F, line l, real e);
conic conic (point M1, point M2, point M3, point M4, point M5);
conic operator * (transform t, conic co);
conic operator + (conic c, explicit pair m);
conic operator + (conic c, explicit point M);
conic operator + (conic c, vector v);
conic operator - (conic c, explicit pair m);
conic operator - (conic c, explicit point M);
conic operator - (conic c, vector v);
conic operator cast (circle c);
conic operator cast (ellipse el);
conic operator cast (hyperbola h);
conic operator cast (parabola p);
conic operator init ();
coord operator init ();
coord operator init ();
coords2 operator init ();
coords2 operator init ();
coords3 operator init ();
coordsys canonicalcartesiansystem (ellipse el);
coordsys canonicalcartesiansystem (explicit conic co);
coordsys canonicalcartesiansystem (hyperbola h);
coordsys canonicalcartesiansystem (parabola p);
coordsys cartesiansystem (pair O=<default>, pair i, pair j);
coordsys coordsys (conic co);
coordsys coordsys (ellipse el);
coordsys coordsys (line l);
coordsys currentcoordsys;
coordsys defaultcoordsys;
coordsys operator * (transform t, coordsys R);
coordsys operator init ();
coord[] array (int n, coord value, int depth=<default>);
coord[] array (int n, coord value, int depth=<default>);
coord[] concat (... coord[][]);
coord[] concat (... coord[][]);
coord[] copy (coord[] a, int depth=<default>);
coord[] copy (coord[] a, int depth=<default>);
coord[] map (coord f(coord), coord[] a);
coord[] map (coord f(coord), coord[] a);
coord[] maxcoords (coord[] in, bool operator <=(coord, coord));
coord[] maxcoords (coord[] in, bool operator <=(coord, coord));
coord[] sequence (coord f(int), int n);
coord[] sequence (coord f(int), int n);
coord[] sort (coord[] a, bool less(coord, coord));
coord[] sort (coord[] a, bool less(coord, coord));
cputime cputime ();
cputime operator init ();
curlSpecifier operator curl (real gamma, int p);
Dir Down;
Dir Left;
Dir operator init ();
Dir Right;
Dir Up;
ellipse ellipse (bqe bqe);
ellipse ellipse (point C, real a, real b, real angle=<default>);
ellipse ellipse (point F1, point F2, point M);
ellipse ellipse (point F1, point F2, real a);
ellipse ellipse (point M1, point M2, point M3, point M4, point M5);
ellipse operator * (real x, ellipse el);
ellipse operator * (transform t, circle c);
ellipse operator * (transform t, ellipse el);
ellipse operator / (ellipse el, real x);
ellipse operator cast (circle c);
ellipse operator cast (conic co);
ellipse operator init ();
face operator cast (path3 p);
face operator init ();
file input (string name=<default>, bool check=<default>, string comment=<default>, string mode=<default>);
file operator cast (null);
file operator init ();
file output (string name=<default>, bool update=<default>, string comment=<default>, string mode=<default>);
file stdin;
file stdout;
filltype Draw (real xmargin=<default>, real ymargin=<default>, pen p=<default>);
filltype Draw;
filltype Fill (real xmargin=<default>, real ymargin=<default>, pen p=<default>);
filltype Fill;
filltype FillDraw (real xmargin=<default>, real ymargin=<default>, pen fillpen=<default>, pen drawpen=<default>);
filltype FillDraw;
filltype filltype (int type=<default>, pen fillpen=<default>, pen drawpen=<default>, void fill2(frame f, path[] g, pen fillpen));
filltype NoFill;
filltype operator init ();
filltype RadialShade (pen penc, pen penr);
filltype RadialShadeDraw (real xmargin=<default>, real ymargin=<default>, pen penc, pen penr, pen drawpen=<default>);
filltype UnFill (real xmargin=<default>, real ymargin=<default>);
filltype UnFill;
FitControl defaultControl;
FitControl operator init ();
FitResult fit (real[] xdata, real[] ydata, real function(real[], real), real[] parameters, FitControl control=<default>);
FitResult fit (real[] xdata, real[] ydata, real[] errors, real function(real[], real), real[] parameters, FitControl control=<default>);
FitResult operator init ();
flowdir Horizontal;
flowdir operator init ();
flowdir Vertical;
frame align (frame f, pair align);
frame BBox (frame)(real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>);
frame bbox (picture pic=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>);
frame circlebarframe (int n=<default>, real barsize=<default>, real radius=<default>, real angle=<default>, pair offset=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
frame crossframe (int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
frame currentpatterns;
frame dotframe (pen p=<default>, filltype filltype=<default>);
frame dotframe;
frame duplicate (path g, int n=<default>, pair space=<default>, pen p=<default>);
frame enclose (string prefix=<default>, object F, string format=<default>);
frame Landscape (frame f);
frame legend (picture pic=<default>, int perline=<default>, real xmargin=<default>, real ymargin=<default>, real linelength=<default>, real hskip=<default>, real vskip=<default>, real maxwidth=<default>, real maxheight=<default>, bool hstretch=<default>, bool vstretch=<default>, pen p=<default>);
frame NoBox (frame f);
frame operator * (real[][] t, frame f);
frame operator * (transform t, frame f);
frame operator cast (object F);
frame operator init ();
frame orientation (frame);
frame pack (pair align=<default> ... object[] inset);
frame Portrait (frame f);
frame Seascape (frame f);
frame stickframe (int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
frame stickframe;
frame tildeframe (int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
frame tildeframe;
frame tiling (string name, picture pic, pair lb=<default>, pair rt=<default>);
frame UpsideDown (frame f);
framedTransformStack operator init ();
framedTransformStack xformStack;
frame[] array (int n, frame value, int depth=<default>);
frame[] concat (... frame[][]);
frame[] copy (frame[] a, int depth=<default>);
frame[] fit (string prefix=<default>, picture[] pictures, string format=<default>, bool view=<default>, string options=<default>, string script=<default>, projection P=<default>);
frame[] fit2 (picture[] pictures, picture all);
frame[] map (frame f(frame), frame[] a);
frame[] sequence (frame f(int), int n);
frame[] sort (frame[] a, bool less(frame, frame));
grid3 operator init ();
grid3 XYgrid (picture pic)(position pos=<default>);
grid3 XYgrid (picture pic);
grid3 XZgrid (picture pic)(position pos=<default>);
grid3 XZgrid (picture pic);
grid3 YXgrid (picture pic)(position pos=<default>);
grid3 YXgrid (picture pic);
grid3 YZgrid (picture pic)(position pos=<default>);
grid3 YZgrid (picture pic);
grid3 ZXgrid (picture pic)(position pos=<default>);
grid3 ZXgrid (picture pic);
grid3 ZYgrid (picture pic)(position pos=<default>);
grid3 ZYgrid (picture pic);
grid3(picture pic)[] operator cast (grid3 gridroutine(picture pic));
grid3(picture pic)[] XYXgrid (position pos=<default>);
grid3(picture pic)[] XYXgrid;
grid3(picture pic)[] XY_XZgrid (position posa=<default>, position posb=<default>);
grid3(picture pic)[] XY_XZgrid;
grid3(picture pic)[] XZXgrid (position pos=<default>);
grid3(picture pic)[] XZXgrid;
grid3(picture pic)[] YXYgrid (position pos=<default>);
grid3(picture pic)[] YXYgrid;
grid3(picture pic)[] YX_YZgrid (position posa=<default>, position posb=<default>);
grid3(picture pic)[] YX_YZgrid;
grid3(picture pic)[] YZYgrid (position pos=<default>);
grid3(picture pic)[] YZYgrid;
grid3(picture pic)[] ZXZgrid (position pos=<default>);
grid3(picture pic)[] ZXZgrid;
grid3(picture pic)[] ZX_ZYgrid (position posa=<default>, position posb=<default>);
grid3(picture pic)[] ZX_ZYgrid;
grid3(picture pic)[] ZYZgrid (position pos=<default>);
grid3(picture pic)[] ZYZgrid;
grid3(picture pic)[][] operator cast (grid3 gridroutine(picture pic));
grid3(picture pic)[][] operator cast (grid3(picture pic)[] gridroutine);
grid3(picture pic)[][] XYZgrid (position pos=<default>);
grid3(picture pic)[][] XYZgrid;
guide graph (pair f(real), real, real, int)(guide join(... guide[]));
guide graph (picture pic=<default>, pair z(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
guide graph (picture pic=<default>, pair[] z, guide join(... guide[])=<default>);
guide graph (picture pic=<default>, real f(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
guide graph (picture pic=<default>, real x(real), real y(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
guide graph (picture pic=<default>, real[] x, real[] y, guide join(... guide[])=<default>);
guide Hermite (... guide[])(real[] splinetype(real[], real[]));
guide Hermite (... guide[]);
guide hermite (real[] x, real[] y, real[] splinetype(real[], real[])=<default>);
guide operator -- (... guide[]);
guide operator --- (... guide[]);
guide operator .. (... guide[])(tensionSpecifier t);
guide operator .. (... guide[]);
guide operator :: (... guide[]);
guide operator cast (curlSpecifier spec);
guide operator cast (cycleToken tok);
guide operator cast (explicit arc a);
guide operator cast (mass M);
guide operator cast (pair);
guide operator cast (path);
guide operator cast (point p);
guide operator cast (tensionSpecifier t);
guide operator controls (pair z);
guide operator controls (pair zout, pair zin);
guide operator init ();
guide operator spec (pair z, int p);
guide polargraph (picture pic=<default>, real r(real), real a, real b, int n=<default>, guide join(... guide[])=<default>);
guide polargraph (picture pic=<default>, real[] r, real[] theta, guide join(... guide[])=<default>);
guide reverse (guide g);
guide Spline (... guide[]);
guide Straight (... guide[]);
guide[] array (int n, guide value, int depth=<default>);
guide[] concat (... guide[][]);
guide[] copy (guide[] a, int depth=<default>);
guide[] graph (pair f(real), real, real, int)(guide join(... guide[]), bool3 cond(real));
guide[] graph (picture pic=<default>, pair z(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
guide[] graph (picture pic=<default>, pair[] z, bool3[] cond, guide join(... guide[])=<default>);
guide[] graph (picture pic=<default>, real f(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
guide[] graph (picture pic=<default>, real x(real), real y(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
guide[] graph (picture pic=<default>, real[] x, real[] y, bool3[] cond, guide join(... guide[])=<default>);
guide[] map (guide f(guide), guide[] a);
guide[] operator cast (pair[] z);
guide[] operator cast (path[] g);
guide[] sequence (guide f(int), int n);
guide[] sort (guide[] a, bool less(guide, guide));
guide[][] connect (pair[][][] points, real[] c, guide join(... guide[]));
guide[][] contour (pair[] z, real[] f, real[] c, guide join(... guide[])=<default>);
guide[][] contour (pair[][] z, real[][] f, real[][] midpoint=<default>, real[] c, guide join(... guide[])=<default>);
guide[][] contour (real f(pair), pair a, pair b, real[] c, int nx=<default>, int ny=<default>, guide join(... guide[])=<default>);
guide[][] contour (real f(real, real), pair a, pair b, real[] c, int nx=<default>, int ny=<default>, guide join(... guide[])=<default>);
guide[][] contour (real[][] f, real[][] midpoint=<default>, pair a, pair b, real[] c, guide join(... guide[])=<default>);
half operator init ();
horner diffdiv (real[] x, real[] y);
horner hdiffdiv (real[] x, real[] y, real[] dy);
horner operator init ();
hsv hsv (pen p);
hsv hsv (real h, real s, real v);
hsv operator cast (pen p);
hsv operator init ();
hyperbola conj (hyperbola h);
hyperbola hyperbola (bqe bqe);
hyperbola hyperbola (point C, real a, real b, real angle=<default>);
hyperbola hyperbola (point M1, point M2, point M3, point M4, point M5);
hyperbola hyperbola (point P1, point P2, real ae, bool byfoci=<default>);
hyperbola operator * (transform t, hyperbola h);
hyperbola operator cast (conic co);
hyperbola operator init ();
indexedTransform indexedTransform (int index, transform t, bool active=<default>);
indexedTransform operator init ();
int abs (int x);
int Allow;
int AND (int a, int b);
int angularsystem;
int animate (string args=<default>, string file=<default>, string format=<default>);
int arcnodesnumber (explicit arc a);
int ascii (string s);
int basealign (pen p=<default>);
int bins (real[] data, int max=<default>);
int Both;
int byte (real x);
int Ceil (real x);
int ceil (real x);
int choose (int n, int k);
int circlenodesnumber (real r);
int circlenodesnumber (real r, real angle1, real angle2);
int circlenodesnumberfactor;
int CLZ (int a);
int coloredNodes;
int coloredSegments;
int conicnodesfactor;
int conicnodesnumber (conic co, real angle1, real angle2, bool dir=<default>);
int convert (string args=<default>, string file=<default>, string format=<default>);
int count;
int countIntersections (path[] p, pair start, pair end);
int CTZ (int a);
int curvilinearsystem;
int debuggerlines;
int delete (string s);
int ellipsenodesnumber (real a, real b);
int ellipsenodesnumber (real a, real b, real angle1, real angle2, bool dir);
int ellipsenodesnumberfactor;
int factorial (int n);
int fillrule (pen p);
int find (bool[] a, int n=<default>);
int find (string s, string t, int pos=<default>);
int Floor (real x);
int floor (real x);
int getint (string name=<default>, int default=<default>, string prompt=<default>, bool store=<default>);
int hex (string s);
int hyperbolanodesnumber (hyperbola h, real angle1, real angle2);
int hyperbolanodesnumberfactor;
int inside (path p, path q, pen fillrule=<default>);
int intMax;
int intMin;
int JOIN_IN;
int JOIN_OUT;
int length (guide g);
int length (path p);
int length (path3 p);
int length (string s);
int linecap (pen p=<default>);
int linejoin (pen p=<default>);
int lookup (tree t, int key);
int mantissaBits;
int max (... int[] a);
int max (int a, int b);
int max (int[] a);
int max (int[][] a);
int max (int[][][] a);
int Max;
int min (... int[] a);
int min (int a, int b);
int min (int[] a);
int min (int[][] a);
int min (int[][][] a);
int Min;
int Move;
int MoveQuiet;
int nCircle;
int ngraph;
int nmesh;
int nodesystem;
int NOT (int a);
int ocgindex;
int operator % (int a, int b);
int operator * (int a, int b);
int operator + (int a);
int operator + (int a, int b);
int operator - (int a);
int operator - (int a, int b);
int operator cast (file);
int operator cast (key k);
int operator ecast (real);
int operator ecast (string);
int operator init ();
int operator ^ (int a, int b);
int OR (int a, int b);
int overwrite (pen p=<default>);
int page;
int parabolanodesnumber (parabola p, real angle1, real angle2);
int parabolanodesnumberfactor;
int preamblenodes;
int precision (file f=<default>, int digits=<default>);
int quadrant (real degrees);
int quotient (int x, int y);
int rand ();
int randMax;
int realDigits;
int relativesystem;
int rename (string from, string to);
int rfind (string s, string t, int pos=<default>);
int Round (real x);
int round (real x);
int search (bool3[] a, bool3 key, bool less(bool3, bool3));
int search (bool[] a, bool key, bool less(bool, bool));
int search (coord[] a, coord key, bool less(coord, coord));
int search (coord[] a, coord key, bool less(coord, coord));
int search (frame[] a, frame key, bool less(frame, frame));
int search (guide[] a, guide key, bool less(guide, guide));
int search (int[] a, int key);
int search (int[] a, int key, bool less(int, int));
int search (Label[] a, Label key, bool less(Label, Label));
int search (Legend[] a, Legend key, bool less(Legend, Legend));
int search (marker[] a, marker key, bool less(marker, marker));
int search (object[] a, object key, bool less(object, object));
int search (pair[] a, pair key, bool less(pair, pair));
int search (path[] a, path key, bool less(path, path));
int search (pen[] a, pen key, bool less(pen, pen));
int search (picture[] a, picture key, bool less(picture, picture));
int search (real[] a, real key);
int search (real[] a, real key, bool less(real, real));
int search (string[] a, string key);
int search (string[] a, string key, bool less(string, string));
int search (triple[] a, triple key, bool less(triple, triple));
int search (void()()[] a, void key()(), bool less(void()(), void()()));
int seconds (string t=<default>, string format=<default>);
int sgn (real x);
int sgnd (int x);
int sgnd (real x);
int size (guide g);
int size (path p);
int size (path3 p);
int size (path[] p);
int sourceline (string file, string text);
int sum (bool[] a);
int sum (int[] a);
int Suppress;
int SuppressQuiet;
int system (string s);
int system (string[] s);
int tell (file f);
int undefined;
int unique (real[] a, real x);
int unique (string[] a, string x);
int Value;
int windingnumber (path[] p, pair z);
int XOR (int a, int b);
int[] array (int n, int value, int depth=<default>);
int[] complement (int[] a, int n);
int[] concat (... int[][]);
int[] copy (int[] a, int depth=<default>);
int[] divisors (int a, int b);
int[] firstnode;
int[] frequency (real[] data, real a, real b, int n);
int[] frequency (real[] data, real[] bins);
int[] lastnode;
int[] map (int f(int), int[] a);
int[] map (int f(real), real[] a);
int[] max (int a, int[] b);
int[] max (int[] a, int b);
int[] max (int[] a, int[] b);
int[] min (int a, int[] b);
int[] min (int[] a, int b);
int[] min (int[] a, int[] b);
int[] numarray;
int[] operator % (int a, int[] b);
int[] operator % (int[] a, int b);
int[] operator % (int[] a, int[] b);
int[] operator * (int a, int[] b);
int[] operator * (int[] a, int b);
int[] operator * (int[] a, int[] b);
int[] operator + (int a, int[] b);
int[] operator + (int[] a);
int[] operator + (int[] a, int b);
int[] operator + (int[] a, int[] b);
int[] operator - (int a, int[] b);
int[] operator - (int[] a);
int[] operator - (int[] a, int b);
int[] operator - (int[] a, int[] b);
int[] operator cast (file);
int[] operator cast (key[] k);
int[] operator ecast (real[]);
int[] operator ecast (string[] a);
int[] operator ^ (int a, int[] b);
int[] operator ^ (int[] a, int b);
int[] operator ^ (int[] a, int[] b);
int[] partialsum (int[] a);
int[] partialsum (int[] a, int[] dx);
int[] reverse (int n);
int[] reverse (int[] a);
int[] sequence (int f(int), int n);
int[] sequence (int n);
int[] sequence (int n, int m);
int[] sort (int[] a);
int[] sort (int[] a, bool less(int, int));
int[] tricoef (side side);
int[][] diagonal (... int[]);
int[][] frequency (pair[] z, pair a, pair b, int nx, int ny=<default>);
int[][] frequency (real[] x, real[] y, pair a, pair b, int nx, int ny=<default>);
int[][] frequency (real[] x, real[] y, real[] xbins, real[] ybins);
int[][] operator * (int a, int[][] b);
int[][] operator * (int[][] a, int b);
int[][] operator * (int[][] a, int[][] b);
int[][] operator + (int[][] a, int[][] b);
int[][] operator - (int[][] a);
int[][] operator - (int[][] a, int[][] b);
int[][] operator cast (file);
int[][] segment (bool[] b);
int[][] segmentlimits (bool[] b);
int[][] sort (int[][] a);
int[][] triangulate (pair[] z);
int[][][] operator cast (file);
inversion inversion (circle c);
inversion inversion (circle c1, circle c2, circle c3);
inversion inversion (circle c1, circle c2, real sgn=<default>);
inversion inversion (point C, real k);
inversion inversion (real k, point C);
inversion operator cast (circle c);
inversion operator init ();
key key (int n, bool active=<default>);
key nil;
key operator cast (int n);
key operator init ();
Label Break;
Label Label (explicit pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (Label L, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (Label L, explicit position position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (Label L, pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (string s, string size=<default>, explicit position position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (string s, string size=<default>, pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label (string s=<default>, string size=<default>, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
Label Label;
Label operator * (real[][] t, Label L);
Label operator * (transform t, Label L);
Label operator cast (object F);
Label operator cast (string s);
Label operator init ();
Label[] array (int n, Label value, int depth=<default>);
Label[] concat (... Label[][]);
Label[] copy (Label[] a, int depth=<default>);
Label[] map (Label f(Label), Label[] a);
Label[] sequence (Label f(int), int n);
Label[] sort (Label[] a, bool less(Label, Label));
Legend Legend (string label, pen plabel=<default>, pen p=<default>, frame mark=<default>, bool above=<default>);
Legend operator init ();
Legend[] array (int n, Legend value, int depth=<default>);
Legend[] concat (... Legend[][]);
Legend[] copy (Legend[] a, int depth=<default>);
Legend[] map (Legend f(Legend), Legend[] a);
Legend[] sequence (Legend f(int), int n);
Legend[] sort (Legend[] a, bool less(Legend, Legend));
light currentlight;
light light (explicit light light);
light light (pen diffuse=<default>, pen ambient=<default>, pen specular=<default>, pen background=<default>, bool viewport=<default>, real x, real y, real z);
light light (pen diffuse=<default>, pen ambient=<default>, pen specular=<default>, pen background=<default>, real specularfactor=<default>, bool viewport=<default> ... triple[] position);
light light (pen[] diffuse, pen[] ambient=<default>, pen[] specular=<default>, pen background=<default>, real specularfactor=<default>, bool viewport=<default>, triple[] position);
light operator init ();
line altitude (side side);
line altitude (vertex V);
line bisector (line l1, line l2, real angle=<default>, bool sharp=<default>);
line bisector (point A, point B, point C, point D, real angle=<default>, bool sharp=<default>);
line bisector (point A, point B, real angle=<default>);
line bisector (segment s, real angle=<default>);
line bisector (side side);
line bisector (vertex V, real angle=<default>);
line cevian (vertex V, point P);
line changecoordsys (coordsys R, line l);
line complementary (explicit line l);
line extend (line l);
line hline (coordsys R=<default>);
line hline;
line intersection (face a, face b);
line isogonal (vertex V, point M);
line isotomic (vertex V, point M);
line line (circle c);
line line (coordsys R=<default>, real a, real b, real c);
line line (coordsys R=<default>, real slope, real origin);
line line (explicit side side);
line line (int a, point A=<default>);
line line (point A, bool extendA=<default>, point B, bool extendB=<default>);
line line (point A=<default>, real a);
line line (real a, point A=<default>);
line line (segment s);
line median (side side);
line median (vertex V);
line operator * (int x, line l);
line operator * (point M, line l);
line operator * (real x, line l);
line operator * (transform t, line l);
line operator + (line l, vector u);
line operator - (line l, vector u);
line operator / (line l, int x);
line operator / (line l, real x);
line operator cast (segment s);
line operator cast (side side);
line operator init ();
line operator init ();
line Ox (coordsys R=<default>);
line Ox;
line Oy (coordsys R=<default>);
line Oy;
line parallel (point M, explicit pair dir);
line parallel (point M, explicit vector dir);
line parallel (point M, line l);
line pedal (side side, point M);
line perpendicular (point M, explicit pair normal);
line perpendicular (point M, explicit vector normal);
line perpendicular (point M, line l);
line radicalline (circle c1, circle c2);
line reverse (line l);
line sector (int n=<default>, int p=<default>, line l1, line l2, real angle=<default>, bool sharp=<default>);
line symmedian (vertex V);
line tangent (circle c, abscissa x);
line tangent (circle c, explicit vector v);
line tangent (circle c, point M);
line tangent (ellipse el, abscissa x);
line tangent (explicit arc a, abscissa x);
line tangent (explicit arc a, point M);
line tangent (hyperbola h, abscissa x);
line tangent (parabola p, abscissa x);
line vline (coordsys R=<default>);
line vline;
linefit leastsquares (real[] x, real[] y);
linefit operator init ();
line[] complementary (explicit segment s);
line[] operator ^^ (line l1, line l2);
line[] operator ^^ (line l1, line[] l2);
line[] operator ^^ (line[] l1, line[] l2);
line[] operator ^^ (line[] l2, line l1);
line[] tangents (circle c, point M);
line[] tangents (ellipse el, point M);
line[] tangents (hyperbola h, point M);
line[] tangents (parabola p, point M);
lm_control_type operator init ();
lm_data_type operator init ();
lm_int_type operator init ();
lm_real_type operator init ();
locateT operator init ();
locateT operator init ();
marginT BeginDotMargin (path, pen);
marginT BeginMargin (path, pen);
marginT BeginPenMargin (path, pen);
marginT DotMargin (path, pen)(real begin, real end);
marginT DotMargin (path, pen);
marginT DotMargins (path, pen);
marginT EndDotMargin (path, pen);
marginT EndMargin (path, pen);
marginT EndPenMargin (path, pen);
marginT Margin (path, pen)(real begin, real end);
marginT Margin (path, pen);
marginT Margins (path, pen);
marginT NoMargin (path, pen)();
marginT NoMargin (path, pen);
marginT operator + (path, pen)(marginT ma(path, pen), marginT mb(path, pen));
marginT operator init ();
marginT PenMargin (path, pen)(real begin, real end);
marginT PenMargin (path, pen);
marginT PenMargins (path, pen);
marginT TrueMargin (path, pen)(real begin, real end);
marker CircleBarIntervalMarker (int i=<default>, int n=<default>, real barsize=<default>, real radius=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, filltype filltype=<default>, bool circleabove=<default>, frame uniform=<default>, bool above=<default>);
marker CrossIntervalMarker (int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
marker dot (pen p=<default>, filltype filltype=<default>);
marker dot;
marker Mark (int n);
marker marker (frame f=<default>, void markroutine(picture pic=<default>, frame f, path g)=<default>, bool above=<default>);
marker marker (path[] g, void markroutine(picture pic=<default>, frame f, path g)=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
marker markthin (path g, pen p=<default>, real thin(real fraction)=<default>, filltype filltype=<default>);
marker nomarker;
marker operator * (transform T, marker m);
marker operator init ();
marker StickIntervalMarker (int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
marker TildeIntervalMarker (int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
marker[] array (int n, marker value, int depth=<default>);
marker[] concat (... marker[][]);
marker[] copy (marker[] a, int depth=<default>);
marker[] map (marker f(marker), marker[] a);
marker[] Mark;
marker[] MarkFill;
marker[] sequence (marker f(int), int n);
marker[] sort (marker[] a, bool less(marker, marker));
mass mass (coordsys R, explicit pair p, real m);
mass mass (explicit point P);
mass mass (point M, real m);
mass masscenter (... mass[] M);
mass operator * (int x, explicit mass M);
mass operator * (real x, explicit mass M);
mass operator * (transform t, mass M);
mass operator + (explicit mass M, int x);
mass operator + (explicit mass M, real x);
mass operator + (mass M1, mass M2);
mass operator - (explicit mass M, int x);
mass operator - (explicit mass M, real x);
mass operator - (mass M1, mass M2);
mass operator / (explicit mass M, int x);
mass operator / (explicit mass M, real x);
mass operator cast (pair m);
mass operator cast (point M);
mass operator init ();
mass[] operator cast (point[] P);
obj operator * (real[][] T, obj o);
obj operator init ();
object align (object F, pair align);
object draw (picture pic=<default>, binarytreeNode node, pair pos, int height, real minDist, real levelDist, real nodeDiameter, pen p=<default>, bool condensed=<default>);
object draw (picture pic=<default>, Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), pair position, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
object draw (picture pic=<default>, Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
object embed3 (string, frame, string, string, string, light, projection);
object object (frame f);
object object (Label L);
object object (Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
object operator * (transform t, explicit object F);
object operator cast (frame f);
object operator cast (Label L);
object operator cast (string s);
object operator init ();
object operator init ();
object[] array (int n, object value, int depth=<default>);
object[] concat (... object[][]);
object[] copy (object[] a, int depth=<default>);
object[] map (object f(object), object[] a);
object[] sequence (object f(int), int n);
object[] sort (object[] a, bool less(object, object));
pair accel (path p, int t, int sign=<default>);
pair accel (path p, real t);
pair Align;
pair align;
pair arcdir (path p, real L);
pair arcpoint (path p, real L);
pair attract (pair m, path g, real fuzz=<default>);
pair beginpoint (path p);
pair bezier (pair a, pair b, pair c, pair d, real t);
pair bezierP (pair a, pair b, pair c, pair d, real t);
pair bezierPP (pair a, pair b, pair c, pair d, real t);
pair bezierPPP (pair a, pair b, pair c, pair d);
pair conj (pair z);
pair coordinates (point M);
pair cos (explicit pair z);
pair currentposition;
pair dateskip;
pair dir (explicit pair z);
pair dir (path p);
pair dir (path p, int t, int sign=<default>, bool normalize=<default>);
pair dir (path p, path q);
pair dir (path p, real t, bool normalize=<default>);
pair dir (real degrees);
pair dot (pair[] a, pair[] b);
pair down;
pair E;
pair endpoint (path p);
pair ENE;
pair ESE;
pair exp (explicit pair z);
pair exp (explicit pair z);
pair expi (real angle);
pair extension (pair p, pair q, pair p, pair q);
pair gamma (explicit pair z);
pair Gaussrandpair ();
pair getpair (string name=<default>, pair default=<default>, string prompt=<default>, bool store=<default>);
pair I;
pair inside (path p, pen fillrule=<default>);
pair interp (explicit pair a, explicit pair b, real t);
pair intersectionpoint (path p, path q, real fuzz=<default>);
pair labeltick (frame d, transform T, path g, ticklocate locate, real val, pair side, int sign, real Size, string ticklabel(real), Label F, real norm=<default>);
pair left;
pair locate (explicit vector v);
pair locate (point P);
pair log (explicit pair z);
pair log (explicit pair z);
pair max (frame f);
pair max (pair[] z);
pair max (path p);
pair max (path[] p);
pair max (pen p);
pair max (picture pic, bool user=<default>);
pair maxAfterTransform (transform t, path[] p);
pair maxbound (pair a, pair b);
pair maxbound (pair[] a);
pair maxbound (pair[][] a);
pair maxbound (pair[][][] a);
pair maxratio (frame f);
pair maxratio (path3 g);
pair maxratio (triple[][] p, pair b);
pair midpoint (path p);
pair min (frame f);
pair min (pair[] z);
pair min (path p);
pair min (path[] p);
pair min (pen p);
pair min (picture pic, bool user=<default>);
pair minAfterTransform (transform t, path[] p);
pair minbound (pair a, pair b);
pair minbound (pair[] a);
pair minbound (pair[][] a);
pair minbound (pair[][][] a);
pair minratio (frame f);
pair minratio (path3 g);
pair minratio (triple[][] p, pair b);
pair N;
pair NE;
pair NNE;
pair NNW;
pair NW;
pair operator * (coordsys R, pair p);
pair operator * (pair a, pair b);
pair operator * (transform t, pair z);
pair operator + (pair a);
pair operator + (pair a, pair b);
pair operator - (pair a);
pair operator - (pair a, pair b);
pair operator / (pair a, pair b);
pair operator / (pair p, coordsys R);
pair operator cast (explicit vector v);
pair operator cast (file);
pair operator cast (int);
pair operator cast (pairOrTriple a);
pair operator cast (point P);
pair operator cast (position P);
pair operator cast (real);
pair operator ecast (string);
pair operator init ();
pair operator tuple (real x, real y);
pair operator ^ (pair a, pair b);
pair operator ^ (pair z, int y);
pair pagenumberalign;
pair pagenumberposition;
pair point (explicit arc a, int x);
pair point (frame f, pair dir);
pair point (guide g, int t);
pair point (object F, pair dir, transform t=<default>);
pair point (path p, int t);
pair point (path p, real t);
pair point (picture pic=<default>, pair dir, bool user=<default>);
pair polar (real r, real theta);
pair postcontrol (path p, int t);
pair postcontrol (path p, real t);
pair precontrol (path p, int t);
pair precontrol (path p, real t);
pair project (triple v, real[][] t);
pair realmult (pair z, pair w);
pair rectify (pair dir);
pair relative (picture pic=<default>, pair z);
pair reldir (path p, real l);
pair relpoint (path p, real l);
pair right;
pair S;
pair Scale (picture pic=<default>, pair z);
pair SE;
pair sin (explicit pair z);
pair size (frame f);
pair size (picture pic, bool user=<default>);
pair sqrt (explicit pair z);
pair SSE;
pair SSW;
pair startposition;
pair sum (pair[] a);
pair SW;
pair ticklabelshift (pair align, pen p=<default>);
pair tickMax (picture pic);
pair tickMin (picture pic);
pair titlealign;
pair titlepageposition;
pair truepoint (picture pic=<default>, pair dir, bool user=<default>);
pair unit (pair z);
pair unityroot (int n, int k=<default>);
pair up;
pair urlskip;
pair viewportmargin;
pair viewportsize;
pair W;
pair WNW;
pair WSW;
pair zero (real);
pairOrTriple operator init ();
pair[] array (int n, pair value, int depth=<default>);
pair[] concat (... pair[][]);
pair[] conj (pair[] a);
pair[] controlSpecifier (guide g, int t);
pair[] copy (pair[] a, int depth=<default>);
pair[] dirSpecifier (guide g, int t);
pair[] endpoints (guide[] a);
pair[] fft (pair[] a, int sign=<default>);
pair[] intersectionpoints (explicit path[] p, explicit path[] q, real fuzz=<default>);
pair[] intersectionpoints (pair A, pair B, real a, real b, real c, real d, real f, real g);
pair[] intersectionpoints (pair A, pair B, real[] equation);
pair[] intersectionpoints (path p, path q, real fuzz=<default>);
pair[] map (pair f(pair), pair[] a);
pair[] operator * (pair a, pair[] b);
pair[] operator * (pair[] a, pair b);
pair[] operator * (pair[] a, pair[] b);
pair[] operator * (transform t, pair[] z);
pair[] operator + (pair a, pair[] b);
pair[] operator + (pair[] a);
pair[] operator + (pair[] a, pair b);
pair[] operator + (pair[] a, pair[] b);
pair[] operator - (pair a, pair[] b);
pair[] operator - (pair[] a);
pair[] operator - (pair[] a, pair b);
pair[] operator - (pair[] a, pair[] b);
pair[] operator / (pair a, pair[] b);
pair[] operator / (pair[] a, pair b);
pair[] operator / (pair[] a, pair[] b);
pair[] operator cast (file);
pair[] operator cast (int[]);
pair[] operator cast (point[] P);
pair[] operator cast (real[]);
pair[] operator ^ (pair a, pair[] b);
pair[] operator ^ (pair[] a, pair b);
pair[] operator ^ (pair[] a, pair[] b);
pair[] pairs (real[] x, real[] y);
pair[] quadraticroots (explicit pair a, explicit pair b, explicit pair c);
pair[] quarticroots (real a, real b, real c, real d, real e);
pair[] reverse (pair[] a);
pair[] sequence (pair f(int), int n);
pair[] sort (pair[] a, bool less(pair, pair));
pair[][] array (int n, pair[] value, int depth=<default>);
pair[][] conj (pair[][] a);
pair[][] copy (pair[][] a, int depth=<default>);
pair[][] diagonal (... pair[]);
pair[][] fft (pair[][] a, int sign=<default>);
pair[][] map (pair[] f(pair[]), pair[][] a);
pair[][] operator * (pair a, pair[][] b);
pair[][] operator * (pair[][] a, pair b);
pair[][] operator * (pair[][] a, pair[][] b);
pair[][] operator + (pair[][] a, pair[][] b);
pair[][] operator - (pair[][] a);
pair[][] operator - (pair[][] a, pair[][] b);
pair[][] operator / (pair[][] a, pair b);
pair[][] operator cast (file);
pair[][] operator cast (int[][]);
pair[][] operator cast (real[][]);
pair[][] sequence (pair[] f(int), int n);
pair[][] sort (pair[][] a, bool less(pair[], pair[]));
pair[][] transpose (pair[][] a);
pair[][][] operator cast (file);
parabola operator * (transform t, parabola p);
parabola operator cast (conic co);
parabola operator init ();
parabola parabola (bqe bqe);
parabola parabola (point F, line l);
parabola parabola (point F, point vertex);
parabola parabola (point F, real a, real angle);
parabola parabola (point M1, point M2, point M3, line l);
parabola parabola (point M1, point M2, point M3, point M4, point M5);
path arc (explicit pair B, explicit pair A, explicit pair C, real r);
path arc (pair c, explicit pair z1, explicit pair z2, bool direction=<default>);
path Arc (pair c, explicit pair z1, explicit pair z2, bool direction=<default>, int n=<default>);
path arc (pair c, real r, real angle1, real angle2);
path arc (pair c, real r, real angle1, real angle2, bool direction);
path Arc (pair c, real r, real angle1, real angle2, bool direction, int n=<default>);
path Arc (pair c, real r, real angle1, real angle2, int n=<default>);
path arcfromcenter (ellipse el, real angle1, real angle2, bool direction=<default>, int n=<default>);
path arcfromcenter (explicit conic co, real angle1, real angle2, int n, bool direction=<default>);
path arcfromcenter (hyperbola h, real angle1, real angle2, int n=<default>, bool direction=<default>);
path arcfromfocus (conic co, real angle1, real angle2, int n=<default>, bool direction=<default>);
path arctopath (arc a, int n);
path arrowbase (path r, pair y, real t, real size);
path box (frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path box (frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path box (pair a, pair b);
path brace (pair a, pair b, real amplitude=<default>);
path buildcycle (... path[] p);
path circle (pair c, real r);
path Circle (pair c, real r, int n=<default>);
path compassmark (pair O, pair A, real position, real angle=<default>);
path cross (int n, bool round=<default>, real r=<default>);
path currentpolarconicroutine (conic co, real angle1, real angle2, int n, bool direction);
path curve (pair c, real f(real), pair a, pair b);
path curve (pair c, real f(real, real), pair a, pair b);
path cutafter (path p, path q);
path cutbefore (path p, path q);
path cuttings;
path ellipse (frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path ellipse (frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path ellipse (pair c, real a, real b);
path fill (frame dest, frame src, filltype filltype=<default>, real xmargin=<default>, real ymargin=<default>);
path fromCenter (conic co, real angle1, real angle2, int n, bool direction);
path fromFocus (conic co, real angle1, real angle2, int n, bool direction);
path gluon (path p, real amp=<default>, real width=<default>);
path halfbox (pair a, pair b);
path line (path p, path q, real[] t);
path momArrowPath (path p, align align, position pos, real offset=<default>, real length=<default>);
path nib (pen p);
path NoModifier (path);
path nullpath;
path nurb (pair z0, pair z1, pair z2, pair z3, real w0, real w1, real w2, real w3, int m);
path operator & (path p, cycleToken tok);
path operator & (path p, path q);
path operator * (coordsys R, path g);
path operator * (inversion i, triangle t);
path operator * (transform t, path g);
path operator cast (circle c);
path operator cast (conic co);
path operator cast (ellipse el);
path operator cast (explicit arc a);
path operator cast (guide);
path operator cast (hyperbola h);
path operator cast (mass M);
path operator cast (pair);
path operator cast (parabola p);
path operator cast (point p);
path operator init ();
path path (pair[] point ... flowdir[] dir);
path photon (path p, real amp=<default>, real width=<default>);
path polarconicroutine (conic co, real angle1, real angle2, int n, bool direction)(conic co);
path polygon (int n);
path randompath (int n, bool cumulate=<default>, guide join(... guide[])=<default>);
path removeDuplicates (path p);
path reverse (path p);
path roundbox (frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path roundbox (frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
path roundedpath (path A, real R, real S=<default>);
path section (path p, real t1, real t2, bool loop=<default>);
path square (pair z1, pair z2);
path subdivide (path p);
path subpath (path p, int a, int b);
path subpath (path p, real a, real b);
path topbox (pair a, pair b);
path trim (path g, real begin, real end);
path uncycle (path p, real t);
path unitcircle;
path unitsquare;
path unstraighten (path p);
path3 Arc (triple c, real r, real theta1, real phi1, real theta2, real phi2, triple normal=<default>, bool direction, int n=<default>);
path3 Arc (triple c, real r, real theta1, real phi1, real theta2, real phi2, triple normal=<default>, int n=<default>);
path3 Arc (triple c, triple v1, triple v2, triple normal=<default>, bool direction=<default>, int n=<default>);
path3 Circle (triple c, real r, triple normal=<default>, int n=<default>);
path3 operator & (path3 p, path3 q);
path3 operator * (real[][] t, path3 g);
path3 operator init ();
path3 path3 (triple[] pre, triple[] point, triple[] post, bool[] straight, bool cyclic);
path3 reverse (path3 p);
path3 roundedpath (path3 A, real r);
path3 subpath (path3 p, int a, int b);
path3 subpath (path3 p, real a, real b);
path3 unstraighten (path3 p);
path3[] segment (triple[] v, bool[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
path[] align (path[] g, transform t=<default>, pair position, pair align, pen p=<default>);
path[] array (int n, path value, int depth=<default>);
path[] bezulate (path[] p);
path[] complement (frame f, path[] g);
path[] concat (... path[][]);
path[] copy (path[] a, int depth=<default>);
path[] cylinder (path3 base, real h, triple axis=<default>, projection P);
path[] map (path f(path), path[] a);
path[] margin (path[] g, real xmargin, real ymargin);
path[] MarkPath;
path[] operator * (transform t, explicit path[] p);
path[] operator cast (guide g);
path[] operator cast (guide[] g);
path[] operator cast (pair[] z);
path[] operator cast (path p);
path[] operator ^^ (explicit path[] p, explicit path[] q);
path[] operator ^^ (explicit path[] p, path q);
path[] operator ^^ (path p, explicit path[] q);
path[] operator ^^ (path p, path q);
path[] plus;
path[] segment (pair[] z, bool[] cond, guide join(... guide[])=<default>);
path[] sequence (path f(int), int n);
path[] sort (path[] a, bool less(path, path));
path[] strokepath (path g, pen p=<default>);
path[] texpath (Label L, bool tex=<default>, bool bbox=<default>);
path[] texpath (string s, pen p, bool tex=<default>, bool bbox=<default>);
path[] _strokepath (path g, pen p=<default>);
path[][] containmentTree (path[] paths);
path[][] textpath (string[] s, pen[] p);
path[][] _texpath (string[] s, pen[] p);
pen addpenarc (pen p);
pen addpenarc;
pen addpenline (pen p);
pen addpenline;
pen adjust (pen p, real arclength, bool cyclic);
pen AliceBlue;
pen AntiqueWhite;
pen Apricot;
pen Aqua;
pen Aquamarine;
pen Aquamarine;
pen authorpen;
pen AvantGarde (string series=<default>, string shape=<default>);
pen Azure;
pen backgroundcolor;
pen backgroundpen;
pen basealign (int n);
pen basealign;
pen Beige;
pen beveljoin;
pen bigvertexpen;
pen Bisque;
pen Bittersweet;
pen black;
pen Black;
pen Black;
pen Black;
pen BlanchedAlmond;
pen blue;
pen Blue;
pen Blue;
pen BlueGreen;
pen BlueViolet;
pen BlueViolet;
pen Bookman (string series=<default>, string shape=<default>);
pen BrickRed;
pen brown;
pen Brown;
pen Brown;
pen BurlyWood;
pen BurntOrange;
pen CadetBlue;
pen CadetBlue;
pen CarnationPink;
pen Cerulean;
pen chartreuse;
pen Chartreuse;
pen Chocolate;
pen cmyk (pen p);
pen cmyk (real c, real m, real y, real k);
pen codepen;
pen colorless (pen p);
pen Coral;
pen CornflowerBlue;
pen CornflowerBlue;
pen Cornsilk;
pen Courier (string series=<default>, string shape=<default>);
pen Crimson;
pen currentpen;
pen Cyan;
pen cyan;
pen Cyan;
pen Cyan;
pen Dandelion;
pen darkblue;
pen DarkBlue;
pen darkbrown;
pen darkcyan;
pen DarkCyan;
pen DarkGoldenrod;
pen darkgray;
pen DarkGray;
pen darkgreen;
pen DarkGreen;
pen darkgrey;
pen DarkKhaki;
pen darkmagenta;
pen DarkMagenta;
pen darkolive;
pen DarkOliveGreen;
pen DarkOrange;
pen DarkOrchid;
pen DarkOrchid;
pen darkred;
pen DarkRed;
pen DarkSalmon;
pen DarkSeaGreen;
pen DarkSlateBlue;
pen DarkSlateGray;
pen DarkTurquoise;
pen DarkViolet;
pen dashdotted;
pen dashed;
pen datepen;
pen deepblue;
pen deepcyan;
pen deepgray;
pen deepgreen;
pen deepgrey;
pen deepmagenta;
pen DeepPink;
pen deepred;
pen DeepSkyBlue;
pen defaultbackpen;
pen defaultpen ();
pen defaultpen;
pen DimGray;
pen DodgerBlue;
pen Dotted (pen p=<default>);
pen Dotted;
pen dotted;
pen doublelinepen;
pen Emerald;
pen evenodd;
pen extendcap;
pen fermionpen;
pen figuremattpen;
pen fillrule (int n);
pen FireBrick;
pen FloralWhite;
pen font (string encoding, string family, string series, string shape);
pen font (string name, real size, string options=<default>);
pen font (string name, string options=<default>);
pen fontcommand (string s);
pen fontsize (real size);
pen fontsize (real size, real lineskip);
pen foregroundcolor;
pen ForestGreen;
pen ForestGreen;
pen fuchsia;
pen Fuchsia;
pen Fuchsia;
pen Gainsboro;
pen ghostpen;
pen GhostWhite;
pen gluonpen;
pen Gold;
pen Goldenrod;
pen Goldenrod;
pen gray (pen p);
pen gray (real gray);
pen gray;
pen Gray;
pen Gray;
pen green;
pen Green;
pen Green;
pen GreenYellow;
pen GreenYellow;
pen grey;
pen heavyblue;
pen heavycyan;
pen heavygray;
pen heavygreen;
pen heavygrey;
pen heavymagenta;
pen heavyred;
pen Helvetica (string series=<default>, string shape=<default>);
pen Honeydew;
pen HotPink;
pen IndianRed;
pen Indigo;
pen institutionpen;
pen interp (pen a, pen b, real t);
pen invisible ();
pen invisible;
pen itempen;
pen Ivory;
pen JungleGreen;
pen Khaki;
pen Lavender;
pen Lavender;
pen LavenderBlush;
pen LawnGreen;
pen LemonChiffon;
pen lightblue;
pen LightBlue;
pen LightCoral;
pen lightcyan;
pen LightCyan;
pen LightGoldenrodYellow;
pen lightgray;
pen lightgreen;
pen LightGreen;
pen lightgrey;
pen LightGrey;
pen lightmagenta;
pen lightolive;
pen LightPink;
pen lightred;
pen LightSalmon;
pen LightSeaGreen;
pen LightSkyBlue;
pen LightSlateGray;
pen LightSteelBlue;
pen lightyellow;
pen LightYellow;
pen Lime;
pen LimeGreen;
pen LimeGreen;
pen linecap (int n);
pen linejoin (int n);
pen Linen;
pen linetype (real[] pattern, real offset=<default>, bool scale=<default>, bool adjust=<default>);
pen linetype (string pattern, real offset=<default>, bool scale=<default>, bool adjust=<default>);
pen linewidth (real x);
pen longdashdotted;
pen longdashed;
pen Magenta;
pen magenta;
pen Magenta;
pen Magenta;
pen Mahogany;
pen makepen (path p);
pen Maroon;
pen Maroon;
pen mean (pen[] p, real opacity(real[])=<default>);
pen MediumAquamarine;
pen mediumblue;
pen MediumBlue;
pen mediumcyan;
pen mediumgray;
pen mediumgreen;
pen mediumgrey;
pen mediummagenta;
pen MediumOrchid;
pen MediumPurple;
pen mediumred;
pen MediumSeaGreen;
pen MediumSlateBlue;
pen MediumSpringGreen;
pen MediumTurquoise;
pen MediumVioletRed;
pen mediumyellow;
pen Melon;
pen MidnightBlue;
pen MidnightBlue;
pen MintCream;
pen MistyRose;
pen miterjoin;
pen miterlimit (real x);
pen Moccasin;
pen momarrowpen;
pen Mulberry;
pen NavajoWhite;
pen Navy;
pen NavyBlue;
pen NewCenturySchoolBook (string series=<default>, string shape=<default>);
pen nobasealign;
pen nullpen;
pen OldLace;
pen olive;
pen Olive;
pen OliveDrab;
pen OliveGreen;
pen opacity (real opacity=<default>, string blend=<default>);
pen operator * (pen a, real b);
pen operator * (real a, pen b);
pen operator * (transform t, pen p);
pen operator + (pen a, pen b);
pen operator + (pen p, real w);
pen operator + (real w, pen p);
pen operator cast (hsv hsv);
pen operator init ();
pen orange;
pen Orange;
pen Orange;
pen OrangeRed;
pen OrangeRed;
pen Orchid;
pen Orchid;
pen overwrite (int n);
pen pagenumberpen;
pen Palatino (string series=<default>, string shape=<default>);
pen paleblue;
pen palecyan;
pen PaleGoldenrod;
pen palegray;
pen palegreen;
pen PaleGreen;
pen palegrey;
pen palemagenta;
pen palered;
pen PaleTurquoise;
pen PaleVioletRed;
pen paleyellow;
pen PapayaWhip;
pen pattern (string s);
pen Peach;
pen PeachPuff;
pen Pen (int n);
pen Pentype (int n);
pen Periwinkle;
pen Peru;
pen photonpen;
pen PineGreen;
pen pink;
pen Pink;
pen Plum;
pen Plum;
pen PowderBlue;
pen ProcessBlue;
pen purple;
pen Purple;
pen Purple;
pen RawSienna;
pen red;
pen Red;
pen Red;
pen RedOrange;
pen RedViolet;
pen rgb (pen p);
pen rgb (real r, real g, real b);
pen rgb (string s);
pen rgba (real[] a);
pen rgbint (int r, int g, int b);
pen Rhodamine;
pen RosyBrown;
pen roundcap;
pen roundjoin;
pen royalblue;
pen RoyalBlue;
pen RoyalBlue;
pen RoyalPurple;
pen RubineRed;
pen SaddleBrown;
pen salmon;
pen Salmon;
pen Salmon;
pen SandyBrown;
pen scalarpen;
pen SeaGreen;
pen SeaGreen;
pen Seashell;
pen Sepia;
pen Sienna;
pen Silver;
pen SkyBlue;
pen SkyBlue;
pen SlateBlue;
pen SlateGray;
pen Snow;
pen solid;
pen springgreen;
pen SpringGreen;
pen SpringGreen;
pen squarecap;
pen squarepen;
pen SteelBlue;
pen steppagenumberpen;
pen Symbol (string series=<default>, string shape=<default>);
pen Tan;
pen Tan;
pen Teal;
pen TealBlue;
pen textpen;
pen thick (pen p=<default>);
pen thin ();
pen Thistle;
pen Thistle;
pen TimesRoman (string series=<default>, string shape=<default>);
pen titlepagepen;
pen titlepen;
pen Tomato;
pen Turquoise;
pen Turquoise;
pen urlpen;
pen vertexpen;
pen Violet;
pen Violet;
pen VioletRed;
pen Wheat;
pen white;
pen White;
pen White;
pen WhiteSmoke;
pen WildStrawberry;
pen Yellow;
pen yellow;
pen Yellow;
pen Yellow;
pen YellowGreen;
pen YellowGreen;
pen YellowOrange;
pen ZapfChancery (string series=<default>, string shape=<default>);
pen ZapfDingbats (string series=<default>, string shape=<default>);
pen zerowinding;
pen[] adjust (picture pic, real min, real max, real rmin, real rmax, pen[] palette);
pen[] array (int n, pen value, int depth=<default>);
pen[] BWRainbow (int NColors, bool two);
pen[] BWRainbow (int NColors=<default>);
pen[] BWRainbow2 (int NColors=<default>);
pen[] cmyk (pen[] Palette);
pen[] colorPen;
pen[] concat (... pen[][]);
pen[] copy (pen[] a, int depth=<default>);
pen[] extend (pen[] palette, pen below, pen above);
pen[] Gradient (int NColors=<default> ... pen[] p);
pen[] Grayscale (int NColors=<default>);
pen[] map (pen f(pen), pen[] a);
pen[] mean (pen[][] palette, real opacity(real[])=<default>);
pen[] monoPen;
pen[] operator + (pen a, pen[] b);
pen[] operator + (pen[] a, pen b);
pen[] palette (real[] f, pen[] palette);
pen[] quantize (pen[] Palette, int n);
pen[] Rainbow (int NColors=<default>);
pen[] sequence (pen f(int), int n);
pen[] sort (pen[] a, bool less(pen, pen));
pen[] Wheel (int NColors=<default>);
pen[][] array (int n, pen[] value, int depth=<default>);
pen[][] copy (pen[][] a, int depth=<default>);
pen[][] interior (picture pic=<default>, guide[][] g, pen[] palette);
pen[][] map (pen[] f(pen[]), pen[][] a);
pen[][] palette (real[][] f, pen[] palette);
pen[][] sequence (pen[] f(int), int n);
pen[][] sort (pen[][] a, bool less(pen[], pen[]));
pen[][] transpose (pen[][] a);
picture arrow (arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>, bool forwards=<default>, marginT margin(path, pen)=<default>, bool center=<default>);
picture arrow2 (arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>);
picture background;
picture bar (pair a, pair d, pen p=<default>);
picture brick (real Hx=<default>, real Hy=<default>, pen p=<default>);
picture checker (real Hx=<default>, real Hy=<default>, pen p=<default>);
picture crosshatch (real H=<default>, pen p=<default>);
picture currentpicture;
picture grid (int Nx, int Ny, pen p=<default>);
picture hatch (real H=<default>, pair dir=<default>, pen p=<default>);
picture legend (Legend[] Legend, int perline=<default>, real linelength, real hskip, real vskip, real maxwidth=<default>, real maxheight=<default>, bool hstretch=<default>, bool vstretch=<default>);
picture legenditem (Legend legenditem, real linelength);
picture operator * (real[][] t, picture orig);
picture operator * (transform t, picture orig);
picture operator cast (face f);
picture operator init ();
picture secondaryX (picture primary=<default>, void f(picture));
picture secondaryY (picture primary=<default>, void f(picture));
picture slopefield (real f(real), pair a, pair b, int nx=<default>, int ny=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
picture slopefield (real f(real, real), pair a, pair b, int nx=<default>, int ny=<default>, real tickfactor=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
picture tableau (frame[] cards, bool number=<default>);
picture tile (real Hx=<default>, real Hy=<default>, pen p=<default>, filltype filltype=<default>);
picture vectorfield (path vector(pair), pair a, pair b, int nx=<default>, int ny=<default>, bool truesize=<default>, real maxlength=<default>, bool cond(pair z)=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
picture vectorfield (path vector(real), path g, int n, bool truesize=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
picture vectorfield (path3 vector(pair v), triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, bool truesize=<default>, real maxlength=<default>, bool cond(pair z)=<default>, pen p=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, string name=<default>, render render=<default>);
picture[] array (int n, picture value, int depth=<default>);
picture[] concat (... picture[][]);
picture[] copy (picture[] a, int depth=<default>);
picture[] map (picture f(picture), picture[] a);
picture[] sequence (picture f(int), int n);
picture[] sort (picture[] a, bool less(picture, picture));
plain plain;
plain_bounds plain_bounds;
plain_scaling plain_scaling;
point angpoint (arc a, real angle);
point angpoint (conic co, real angle);
point angpoint (explicit circle c, real x);
point angpoint (explicit ellipse el, real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
point angpoint (explicit hyperbola h, real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
point angpoint (explicit parabola p, real x);
point arcsubtendedcenter (point A, point B, real angle);
point attract (point M, path g, real fuzz=<default>);
point bisectorpoint (side side);
point centroid (point A, point B, point C);
point centroid (triangle t);
point cevian (side side, point P);
point changecoordsys (coordsys R, point M);
point circumcenter (point A, point B, point C);
point circumcenter (triangle t);
point conj (explicit point M);
point curpoint (arc a, real x);
point curpoint (conic co, real x);
point curpoint (explicit circle c, real x);
point curpoint (explicit ellipse el, real x);
point curpoint (explicit parabola p, real x);
point curpoint (line l, real x);
point excenter (point A, point B, point C);
point excenter (side side);
point foot (side side);
point foot (vertex V);
point gergonne (triangle t);
point incenter (point A, point B, point C);
point incenter (triangle t);
point intersectionpoint (line l1, line l2);
point intouch (side side);
point inverse (real k, point A, point M);
point isogonal (side side, point M);
point isogonalconjugate (triangle t, point M);
point isotomic (side side, point M);
point isotomicconjugate (triangle t, point M);
point locate (pair p);
point midpoint (segment s);
point midpoint (side side);
point operator * (explicit pair p1, explicit point p2);
point operator * (explicit point P1, explicit pair p2);
point operator * (explicit point P1, explicit point P2);
point operator * (inversion i, point P);
point operator * (real x, explicit point P);
point operator * (transform t, explicit point P);
point operator + (explicit pair m, explicit vector v);
point operator + (explicit pair p1, explicit point p2);
point operator + (explicit point P1, explicit pair p2);
point operator + (explicit point P1, explicit point P2);
point operator + (point M, explicit vector v);
point operator - (explicit pair m, explicit vector v);
point operator - (explicit pair p1, explicit point P2);
point operator - (explicit point P);
point operator - (explicit point P1, explicit pair p2);
point operator - (explicit point P1, explicit point P2);
point operator - (point M, explicit vector v);
point operator / (explicit point P, real x);
point operator / (real x, explicit point P);
point operator cast (mass m);
point operator cast (pair p);
point operator cast (trilinear tri);
point operator cast (vector v);
point operator cast (vertex V);
point operator init ();
point origin (coordsys R=<default>);
point origin;
point orthocentercenter (point A, point B, point C);
point orthocentercenter (triangle t);
point point (arc a, abscissa l);
point point (arc a, real x);
point point (circle c, abscissa l);
point point (circle c, explicit vector v);
point point (circle c, point M);
point point (coordsys R, explicit point M, real m=<default>);
point point (coordsys R, pair p, real m=<default>);
point point (ellipse el, abscissa l);
point point (explicit circle c, explicit int x);
point point (explicit circle c, explicit real x);
point point (explicit conic co, abscissa l);
point point (explicit conic co, explicit int x);
point point (explicit conic co, explicit real x);
point point (explicit ellipse el, explicit int x);
point point (explicit ellipse el, explicit real x);
point point (explicit hyperbola h, explicit int x);
point point (explicit hyperbola h, explicit real x);
point point (explicit mass m);
point point (explicit pair p, real m);
point point (explicit parabola p, explicit int x);
point point (explicit parabola p, explicit real x);
point point (explicit vector u);
point point (explicit vertex V);
point point (hyperbola h, abscissa l);
point point (line l, abscissa x);
point point (line l, explicit int x);
point point (line l, explicit real x);
point point (parabola p, abscissa l);
point point (trilinear tri);
point ppoint (arc a, real x);
point radicalcenter (circle c1, circle c2);
point radicalcenter (circle c1, circle c2, circle c3);
point relpoint (arc a, real x);
point relpoint (explicit circle c, real x);
point relpoint (explicit conic co, explicit int x);
point relpoint (explicit conic co, explicit real x);
point relpoint (explicit ellipse el, real x);
point relpoint (explicit hyperbola h, real x);
point relpoint (explicit parabola p, real x);
point relpoint (line l, real x);
point symmedian (side side);
point symmedian (triangle t);
point[] fermat (triangle t);
point[] intersectionpoints (arc a, conic co);
point[] intersectionpoints (arc a, line l);
point[] intersectionpoints (arc a1, arc a2);
point[] intersectionpoints (bqe bqe1, bqe bqe2);
point[] intersectionpoints (circle a, ellipse b);
point[] intersectionpoints (circle a, hyperbola b);
point[] intersectionpoints (circle a, parabola b);
point[] intersectionpoints (circle c, line l);
point[] intersectionpoints (circle c1, circle c2);
point[] intersectionpoints (conic co, arc a);
point[] intersectionpoints (conic co, line l);
point[] intersectionpoints (conic co, triangle t, bool extended=<default>);
point[] intersectionpoints (conic co1, conic co2);
point[] intersectionpoints (ellipse a, circle b);
point[] intersectionpoints (ellipse a, ellipse b);
point[] intersectionpoints (ellipse a, hyperbola b);
point[] intersectionpoints (ellipse a, parabola b);
point[] intersectionpoints (ellipse el, line l);
point[] intersectionpoints (hyperbola a, circle b);
point[] intersectionpoints (hyperbola a, ellipse b);
point[] intersectionpoints (hyperbola a, hyperbola b);
point[] intersectionpoints (hyperbola a, parabola b);
point[] intersectionpoints (hyperbola h, line l);
point[] intersectionpoints (line l, arc a);
point[] intersectionpoints (line l, circle c);
point[] intersectionpoints (line l, conic co);
point[] intersectionpoints (line l, ellipse el);
point[] intersectionpoints (line l, hyperbola h);
point[] intersectionpoints (line l, parabola p);
point[] intersectionpoints (line l, path g);
point[] intersectionpoints (line l, triangle t, bool extended=<default>);
point[] intersectionpoints (parabola a, circle b);
point[] intersectionpoints (parabola a, ellipse b);
point[] intersectionpoints (parabola a, hyperbola b);
point[] intersectionpoints (parabola a, parabola b);
point[] intersectionpoints (parabola p, line l);
point[] intersectionpoints (triangle t, conic co, bool extended=<default>);
point[] intersectionpoints (triangle t, line l, bool extended=<default>);
point[] operator cast (mass[] m);
point[] operator cast (pair[] p);
point[] sameside (point M, line l1, line l2);
point[] standardizecoordsys (coordsys R=<default>, bool warn=<default> ... point[] M);
position BeginPoint;
position bottom;
position EndPoint;
position middle;
position MidPoint;
position operator cast (int x);
position operator cast (pair x);
position operator cast (real x);
position operator init ();
position Relative (real position);
position top;
problem operator init ();
processtime operator init ();
projection currentprojection;
projection operator init ();
projection projection (triple camera, triple up=<default>, triple target=<default>, triple normal=<default>, real zoom=<default>, real angle=<default>, pair viewportshift=<default>, bool showtarget=<default>, bool autoadjust=<default>, bool center=<default>, transformation projector(triple camera, triple up, triple target));
real abs (coordsys R, pair m);
real abs (explicit point M);
real abs (pair z);
real abs (real x);
real abs (triple v);
real acos (real x);
real aCos (real x);
real acosh (real x);
real acot (real x);
real acsc (real x);
real adjust (real h, real error, real tolmin, real tolmax, RKTableau tableau);
real angle (arc a);
real angle (explicit point M, coordsys R=<default>, bool warn=<default>);
real angle (explicit vector v, coordsys R=<default>, bool warn=<default>);
real angle (line l, coordsys R=<default>);
real angle (line l1, line l2);
real angle (pair z, bool warn=<default>);
real angle (transform t);
real animationdelay;
real approximate (real t);
real arcarrowangle;
real arcarrowfactor;
real arcarrowsize (pen p=<default>);
real arclength (arc a);
real arclength (circle c);
real arclength (ellipse el);
real arclength (ellipse el, real angle1, real angle2, bool direction=<default>, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
real arclength (parabola p);
real arclength (parabola p, real angle);
real arclength (parabola p, real angle1, real angle2);
real arclength (path p);
real arclength (path3 p);
real arctime (path p, real l);
real arctime (path3 p, real dval);
real arrow2sizelimit;
real arrowangle;
real arrowbarb;
real arrowdir;
real arrowfactor;
real arrowhookfactor;
real arrowlength;
real arrowsize (pen p=<default>);
real arrowsizelimit;
real arrowtexfactor;
real asec (real x);
real asin (real x);
real aSin (real x);
real asinh (real x);
real atan (real x);
real aTan (real x);
real atan2 (real y, real x);
real atanh (real x);
real axiscoverage;
real axislabelfactor;
real azimuth (triple v, bool warn=<default>);
real barfactor;
real barmarksize (pen p=<default>);
real barmarksizefactor;
real barsize (pen p=<default>);
real bigvertexsize;
real binomial (real n, real k);
real bp;
real bracedefaultratio;
real braceinnerangle;
real bracemidangle;
real braceouterangle;
real calculateScaling (string dir, coord[] coords, real size, bool warn=<default>);
real calculateScaling (string dir, coord[] coords, real size, bool warn=<default>);
real calculateScaling (string dir, coord[] m, coord[] M, real size, bool warn=<default>);
real calculateScaling (string dir, coord[] m, coord[] M, real size, bool warn=<default>);
real camerafactor;
real cbrt (real x);
real centerToFocus (ellipse el, real a);
real change2 (triple[][] a);
real circlemarkradius (pen p=<default>);
real circlemarkradiusfactor;
real circleprecision;
real circlescale;
real cm;
real codeskip;
real colatitude (triple v, bool warn=<default>);
real Cos (real deg);
real cos (real x);
real cosh (real x);
real cot (real x);
real crossmarksize (pen p=<default>);
real crossmarksizefactor;
real csc (real x);
real defaultexcursion;
real degrees (arc a);
real degrees (explicit point M, coordsys R=<default>, bool warn=<default>);
real degrees (line l, coordsys R=<default>);
real degrees (line l1, line l2);
real degrees (pair z, bool warn=<default>);
real Degrees (real radians);
real degrees (real radians);
real degrees (rmf a, rmf b);
real degrees (vector v, coordsys R=<default>, bool warn=<default>);
real determinant (real[][] a);
real dirtime (path p, pair z);
real distance (line l, point M);
real distance (point M, line l);
real dot (explicit pair A, point B);
real dot (explicit pair z, explicit pair w);
real dot (point A, explicit pair B);
real dot (point A, point B);
real dot (real[] a, real[] b);
real dot (triple u, triple v);
real dotfactor;
real dotsize (pen p=<default>);
real doublelinespacing;
real duplicateFuzz;
real elle (real phi, real k);
real eps;
real eps;
real EPS;
real eps;
real epsgeo;
real epsilon;
real epsilon;
real erf (real x);
real erfc (real x);
real error (real error, real initial, real lowOrder, real norm, real diff);
real exp (real x);
real expansionfactor;
real expm1 (real x);
real exradius (point A, point B, point C);
real exradius (side side);
real fabs (real x);
real fhorner (real)(horner sh);
real figureborder;
real fmod (real x, real y);
real focusToCenter (ellipse el, real a);
real fontsize (pen p=<default>);
real frac (real x);
real fspline (real)(real[] x, real[] y, real[] splinetype(real[], real[])=<default>);
real fuzz;
real gamma (real x);
real gapfactor;
real Gaussian (real x);
real Gaussian (real x, real sigma);
real Gaussrand ();
real getreal (string name=<default>, real default=<default>, string prompt=<default>, bool store=<default>);
real gluonamplitude;
real gluonratio;
real hatchepsilon;
real hwratio;
real hypot (real x, real y);
real identity (real x);
real inch;
real inches;
real incircle (pair a, pair b, pair c, pair d);
real inf;
real infinity;
real infinity;
real inradius (point A, point B, point C);
real inradius (triangle t);
real interp (real a, real b, real t);
real interpolate (real[] x, real[] y, real x0);
real interpolate (real[] x, real[] y, real x0, int i);
real intersect (pair p, pair q, pair z);
real intersect (triple P, triple Q, triple n, triple Z);
real itemskip;
real Jn (int n, real x);
real kurtosis (real[] A);
real kurtosisexcess (real[] A);
real labelmargin (pen p=<default>);
real labelmargin;
real latitude (triple v, bool warn=<default>);
real layout (int level, TreeNode node);
real ldexp (real x, int e);
real legendhskip;
real legendlinelength;
real legendmargin;
real legendmarkersize;
real legendmaxrelativewidth;
real legendvskip;
real length (explicit point M);
real length (pair z);
real length (segment s);
real length (triple v);
real linear (real)(real S(real x)=<default>, real Min, real Max);
real linemargin ();
real linemargin;
real linemargin;
real lineskip (pen p=<default>);
real linewidth (pen p=<default>);
real LM_DWARF;
real lm_enorm (int n, real[] x, int offset=<default>);
real LM_MACHEP;
real LM_SQRT_DWARF;
real LM_SQRT_GIANT;
real LM_USERTOL;
real log (real x);
real log10 (real x);
real log1p (real x);
real longitude (triple v, bool warn=<default>);
real magneticRadius;
real markangleradius (pen p=<default>);
real markangleradius;
real markangleradiusfactor;
real markanglespace (pen p=<default>);
real markanglespace;
real markanglespacefactor;
real max (... real[] a);
real max (real a, real b);
real max (real M, scaling s, coord[] c);
real max (real M, scaling s, coord[] c);
real max (real[] a);
real max (real[][] a);
real max (real[][][] a);
real maxlength (pair a, pair b, int nx, int ny);
real maxlength (triple f(pair z), pair a, pair b, int nu, int nv);
real mean (real[] A);
real min (... real[] a);
real min (real a, real b);
real min (real m, scaling s, coord[] c);
real min (real m, scaling s, coord[] c);
real min (real[] a);
real min (real[][] a);
real min (real[][][] a);
real minblockheight;
real minblockwidth;
real mincirclediameter;
real minDistDefault;
real minipagemargin;
real minipagewidth;
real minvertexangle;
real miterlimit (pen p=<default>);
real mm;
real momarrowfactor;
real momarrowlength;
real momarrowmargin;
real momarrowoffset;
real momarrowsize (pen p=<default>);
real newton (int iterations=<default>, real f(real), real fprime(real), real x, bool verbose=<default>);
real newton (int iterations=<default>, real f(real), real fprime(real), real x1, real x2, bool verbose=<default>);
real nodeMarginDefault;
real norm (real[] a);
real norm (real[][] a);
real norm (triple[][] a);
real offset (pen p);
real opacity (pen p);
real operator % (real a, real b);
real operator * (real a, real b);
real operator + (real a);
real operator + (real a, real b);
real operator - (real a);
real operator - (real a, real b);
real operator / (int a, int b);
real operator / (real a, real b);
real operator cast (file);
real operator cast (int);
real operator ecast (string);
real operator init ();
real operator ^ (point M, explicit circle c);
real operator ^ (real a, real b);
real operator ^ (real x, int y);
real pageheight;
real pagemargin;
real pagewidth;
real perpfactor;
real phi1 (real x);
real phi2 (real x);
real phi3 (real x);
real photonamplitude;
real photonratio;
real pi;
real polar (triple v, bool warn=<default>);
real pow10 (real x);
real pt;
real pwhermite (real)(real[] x, real[] y, real[] dy);
real radians (real degrees);
real radius (path p, real t);
real radius (path3 p, real t);
real radius (triple z0, triple c0, triple c1, triple z1, real t);
real rd (real x, real y, real z);
real realEpsilon;
real realMax;
real realMin;
real relativedistance (real theta, real phi, real t, bool atleast);
real reltime (path p, real l);
real remainder (real x, real y);
real rf (real x, real y, real z);
real rms (real[] A);
real ScaleX (picture pic=<default>, real x);
real ScaleY (picture pic=<default>, real y);
real ScaleZ (picture pic=<default>, real z);
real sec (real x);
real sharpangle (line l1, line l2);
real sharpdegrees (line l1, line l2);
real side (pair a, pair b, pair c);
real simpson (real f(real), real a, real b, real acc=<default>, real dxmax=<default>);
real Sin (real deg);
real sin (real x);
real sinh (real x);
real skewness (real[] A);
real slope (path g, explicit pair z, int n=<default>);
real slope (path g, real x, int n=<default>);
real SQR (real x);
real sqrt (real x);
real sqrtEpsilon;
real stdev (real[] A);
real stepfactor;
real stepfraction;
real stickmarksize (pen p=<default>);
real stickmarksizefactor;
real stickmarkspace (pen p=<default>);
real stickmarkspacefactor;
real straightness (path3 p, int t);
real straightness (triple z0, triple c0, triple c1, triple z1);
real sum (real[] a);
real Tan (real deg);
real tan (real x);
real tanh (real x);
real Ticksize;
real ticksize;
real tildemarksize (pen p=<default>);
real tildemarksizefactor;
real time (path g, explicit pair z, int n=<default>);
real time (path g, real x, int n=<default>);
real titleskip;
real treeLevelStep;
real treeMinNodeWidth;
real treeNodeStep;
real trembleAngle;
real trembleFrequency;
real trembleFuzz ();
real trembleRandom;
real unitrand ();
real upscale (real b, real a);
real value (path g, explicit pair z, int n=<default>);
real value (path g, real x, int n=<default>);
real variance (real[] A);
real variancebiased (real[] A);
real vertexsize;
real xpart (pair z);
real xpart (triple v);
real xtrans (real[][] t, real x);
real xtrans (transform t, real x);
real ylabelwidth;
real Yn (int n, real x);
real ypart (pair z);
real ypart (triple v);
real ytrans (real[][] t, real y);
real ytrans (transform t, real y);
real zerotickfuzz;
real zpart (triple v);
real ztrans (real[][] t, real z);
real[] abs (pair[] a);
real[] abs (real[] a);
real[] abs (triple[] a);
real[] acos (real[] a);
real[] acosh (real[] a);
real[] approximate (real[] T);
real[] array (int n, real value, int depth=<default>);
real[] arrowbasepoints (path base, path left, path right, real default=<default>);
real[] asin (real[] a);
real[] asinh (real[] a);
real[] atan (real[] a);
real[] atanh (real[] a);
real[] bangles (picture pic=<default>, parabola p);
real[] cbrt (real[] a);
real[] clamped (real[], real[])(real slopea, real slopeb);
real[] Coeff;
real[] colors (pen p);
real[] concat (... real[][]);
real[] copy (real[] a, int depth=<default>);
real[] cos (real[] a);
real[] cosh (real[] a);
real[] cubicroots (real a, real b, real c, real d);
real[] curlSpecifier (guide g, int t);
real[] exp (real[] a);
real[] expm1 (real[] a);
real[] fabs (real[] a);
real[] identity (real[] a);
real[] intersect (path g, explicit pair p, real fuzz=<default>);
real[] intersect (path g, explicit point P, real fuzz=<default>);
real[] intersect (path p, path q, real fuzz=<default>);
real[] intersect (path3 p, path3 q, real fuzz=<default>);
real[] intersections (path p, explicit pair a, explicit pair b, real fuzz=<default>);
real[] linear (real[] x, real[] y);
real[] linetype (pen p=<default>);
real[] log (real[] a);
real[] log10 (real[] a);
real[] log1p (real[] a);
real[] map (real f(pair), pair[] a);
real[] map (real f(real), real[] a);
real[] max (real a, real[] b);
real[] max (real[] a, real b);
real[] max (real[] a, real[] b);
real[] maxtimes (path p);
real[] maxtimes (path3 p);
real[] min (real a, real[] b);
real[] min (real[] a, real b);
real[] min (real[] a, real[] b);
real[] mintimes (path p);
real[] mintimes (path3 p);
real[] monotonic (real[] x, real[] y);
real[] natural (real[] x, real[] y);
real[] newton (int iterations=<default>, real[] f(real[]), real[][] jacobian(real[]), real[] t);
real[] notaknot (real[] x, real[] y);
real[] operator % (real a, real[] b);
real[] operator % (real[] a, real b);
real[] operator % (real[] a, real[] b);
real[] operator * (real a, real[] b);
real[] operator * (real[] a, real b);
real[] operator * (real[] a, real[] b);
real[] operator * (real[] a, real[][] b);
real[] operator * (real[][] a, real[] b);
real[] operator + (real a, real[] b);
real[] operator + (real[] a);
real[] operator + (real[] a, real b);
real[] operator + (real[] a, real[] b);
real[] operator - (real a, real[] b);
real[] operator - (real[] a);
real[] operator - (real[] a, real b);
real[] operator - (real[] a, real[] b);
real[] operator / (int a, int[] b);
real[] operator / (int[] a, int b);
real[] operator / (int[] a, int[] b);
real[] operator / (real a, real[] b);
real[] operator / (real[] a, real b);
real[] operator / (real[] a, real[] b);
real[] operator cast (file);
real[] operator cast (int[]);
real[] operator ecast (string[] a);
real[] operator ^ (real a, real[] b);
real[] operator ^ (real[] a, real b);
real[] operator ^ (real[] a, real[] b);
real[] partialsum (real[] a);
real[] partialsum (real[] a, real[] dx);
real[] periodic (real[] x, real[] y);
real[] pow10 (real[] a);
real[] quadraticroots (real a, real b, real c);
real[] realquarticroots (real a, real b, real c, real d, real e);
real[] reverse (real[] a);
real[] rgba (pen p);
real[] sample (path3 g, real r, real relstep=<default>);
real[] sequence (real f(int), int n);
real[] sequencereal;
real[] sin (real[] a);
real[] sinh (real[] a);
real[] solve (real[][] a, real[] b, bool warn=<default>);
real[] solveBVP (real[] f(real, real[]), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>, real[] initial(real[]), real[] discrepancy(real[]), real[] guess, int iterations=<default>);
real[] sort (real[] a);
real[] sort (real[] a, bool less(real, real));
real[] Spline (real[] x, real[] y);
real[] sqrt (real[] a);
real[] tan (real[] a);
real[] tangent (path p, path q, bool side);
real[] tanh (real[] a);
real[] texsize (string s, pen p=<default>);
real[] times (path p, explicit pair z);
real[] times (path p, real x);
real[] tridiagonal (real[] a, real[] b, real[] c, real[] f);
real[] uniform (real a, real b, int n);
real[] zero (int n);
real[] _cputime ();
real[] _projection ();
real[](real[], real[])[] Spline;
real[][] array (int n, real[] value, int depth=<default>);
real[][] bangles (picture pic=<default>, hyperbola h);
real[][] copy (real[][] a, int depth=<default>);
real[][] diagonal (... real[]);
real[][] finiteDifferenceJacobian (real[] f(real[]), real[] t, real[] h=<default>);
real[][] identity (int n);
real[][] identity4;
real[][] intersections (pair a, pair b, path p);
real[][] intersections (path p, path q, real fuzz=<default>);
real[][] intersections (path3 p, path3 q, real fuzz=<default>);
real[][] intersections (path3 p, triple[][] p, real fuzz=<default>);
real[][] inverse (real[][] a);
real[][] map (real[] f(real[]), real[][] a);
real[][] operator * (real a, real[][] b);
real[][] operator * (real[][] a, real b);
real[][] operator * (real[][] a, real[][] b);
real[][] operator + (real[][] a, real[][] b);
real[][] operator - (real[][] a);
real[][] operator - (real[][] a, real[][] b);
real[][] operator / (real[][] a, real b);
real[][] operator cast (file);
real[][] operator cast (int[][]);
real[][] scale (real x, real y, real z);
real[][] scale3 (real s);
real[][] sequence (real[] f(int), int n);
real[][] shiftless (real[][] t);
real[][] solve (real[][] a, real[][] b, bool warn=<default>);
real[][] sort (real[][] a);
real[][] sort (real[][] a, bool less(real[], real[]));
real[][] transpose (real[][] a);
real[][] zero (int n, int m);
real[][][] operator cast (file);
Relation operator - (Relation r);
Relation operator init ();
Relation r3;
Relation r4a;
Relation r4b;
revolution cone (triple c=<default>, real r, real h, triple axis=<default>, int n=<default>);
revolution cylinder (triple c=<default>, real r, real h, triple axis=<default>);
revolution operator * (real[][] t, revolution r);
revolution operator init ();
revolution sphere (triple c=<default>, real r, int n=<default>);
RKTableau Euler;
RKTableau E_Euler;
RKTableau E_PC;
RKTableau E_RK2;
RKTableau E_RK3BS;
RKTableau operator init ();
RKTableau PC;
RKTableau RK2;
RKTableau RK3;
RKTableau RK3BS;
RKTableau RK4;
RKTableau RK5;
RKTableau RK5DP;
RKTableau RK5F;
sCAD operator init ();
scaleT Broken (real a, real b, bool automin=<default>, bool automax=<default>);
scaleT BrokenLog (real a, real b, bool automin=<default>, bool automax=<default>);
scaleT Linear (bool automin=<default>, bool automax=<default>, real s=<default>, real intercept=<default>);
scaleT Linear;
scaleT Log (bool automin=<default>, bool automax=<default>);
scaleT Log;
scaleT Logarithmic;
ScaleT operator init ();
scaleT operator init ();
scaleT scaleT (real T(real x), real Tinv(real x), bool logarithmic=<default>, bool automin=<default>, bool automax=<default>);
scaling operator init ();
scaling operator init ();
scientific operator init ();
scientific scientific (real x);
segment case1 (pair p0, pair p1, int edge);
segment case2 (pair p0, pair p1, pair p2, real v0, real v1, real v2, int edge);
segment case3 (pair p0, pair p1, pair p2, real v0, real v1, real v2, int edge=<default>);
segment checktriangle (pair p0, pair p1, pair p2, real v0, real v1, real v2, int edge=<default>);
segment operator cast (line l);
segment operator init ();
segment operator init ();
segment segment (explicit side side);
segment segment (line l);
segment segment (point A, point B);
settings settings;
side Center;
side LeftSide;
side NoSide;
side operator * (real x, side s);
side operator init ();
side opposite (vertex V);
side Relative (explicit pair align);
side RightSide;
skeleton operator init ();
slice cut (path p, path knife, int n);
slice firstcut (path p, path knife);
slice lastcut (path p, path knife);
slice operator init ();
solution integrate (real y, real c=<default>, real g(real t, real y), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>);
Solution integrate (real[] y, real[] f(real t, real[] y), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>);
solution operator init ();
Solution operator init ();
splitface operator init ();
splitface split (face a, face cut, projection P);
string ask (string prompt);
string asydir ();
string asywrite (string s, string preamble=<default>);
string autoformat (string format=<default>, real norm ... real[] a);
string baseline (string s, string template=<default>);
string baselinetemplate;
string blend (pen p);
string bullet;
string bulletcolor (string color);
string cd (string s=<default>);
string Centered;
string colorspace (pen p);
string conditionlength;
string conictype (bqe bqe);
string cputimeformat;
string cropcode (string s);
string debugger (string file, int line, int column, code s=<default>);
string defaultfilename;
string defaultformat (int n, string trailingzero=<default>, bool fixed=<default>, bool signed=<default>);
string DefaultFormat (real);
string defaultformat;
string DefaultLogFormat (real)(int base);
string DefaultLogFormat (real);
string defaultmassformat;
string defaultseparator;
string differentlengths;
string downcase (string s);
string Embed (string name, string text=<default>, string options=<default>, real width=<default>, real height=<default>);
string embed (string name, string text=<default>, string options=<default>, real width=<default>, real height=<default>);
string embed (string name, string text=<default>, string options=<default>, real width=<default>, real height=<default>, string image=<default>);
string embedplayer (string name, string text=<default>, string options=<default>, real width=<default>, real height=<default>);
string erase (string s, int pos, int n);
string file (string s);
string font (pen p=<default>);
string format (real x, string locale=<default>);
string Format (real)(string s=<default>);
string format (string format, int x, string locale=<default>);
string format (string format, real x, string locale=<default>);
string format (string format, string separator, real x, string locale=<default>);
string getc (file f);
string getstring (string name=<default>, string default=<default>, string prompt=<default>, bool store=<default>);
string graphic (string name, string options=<default>);
string hex (pen p);
string hyperlink (string url, string text);
string includegraphicscommand;
string insert (string s, int pos, string t);
string italic (string s);
string jobname (string name);
string LeftJustified;
string link (string label, string text=<default>);
string link (string label, string text=<default>);
string locale (string s=<default>);
string locatefile (string file);
string location ();
string LogFormat (real)(int base);
string LogFormat (real);
string massformat (string format=<default>, string s, mass M);
string math (real x);
string math (string s);
string max (string a, string b);
string max (string[] a);
string max (string[][] a);
string max (string[][][] a);
string min (string a, string b);
string min (string[] a);
string min (string[][] a);
string min (string[][][] a);
string minipage (string s, real width=<default>);
string mktemp (string s);
string morepoints;
string nativeformat ();
string newbulletcolor;
string nopoint;
string noprimary;
string NoZeroFormat (real);
string oldbulletcolor;
string OmitFormat (real)(string s=<default> ... real[] x);
string operator + (string a, string b);
string operator cast (file);
string operator ecast (int);
string operator ecast (pair);
string operator ecast (real);
string operator ecast (triple);
string operator init ();
string outformat (string format=<default>);
string outname ();
string outprefix (string prefix=<default>);
string pad (int num, int digits, string pad=<default>);
string pad (real num, int digits, string pad=<default>);
string pad (string str, int count, string pad=<default>);
string pattern (pen p);
string phantom (string s);
string readline (string prompt=<default>, string name=<default>, bool tabcompletion=<default>);
string replace (string s, string before, string after);
string replace (string s, string[][] translate);
string reverse (string s);
string RightJustified;
string signedtrailingzero;
string string (int x);
string string (real x, int digits=<default>);
string stripdirectory (string s);
string stripextension (string s);
string stripfile (string s);
string stripsuffix (string f, string suffix=<default>);
string substr (string s, int pos, int n=<default>);
string texcolor (pen p);
string TeXify (string s);
string texify (string s);
string time (int seconds, string format=<default>);
string time (string format=<default>);
string trailingzero;
string upcase (string s);
string verbatim (string s);
string VERSION;
string VERSION;
string[] array (int n, string value, int depth=<default>);
string[] codefile;
string[] concat (... string[][]);
string[] copy (string[] a, int depth=<default>);
string[] file3;
string[] history (int n=<default>);
string[] history (string name, int n=<default>);
string[] lm_infmsg;
string[] lm_shortmsg;
string[] map (string f(string), string[] a);
string[] max (string a, string[] b);
string[] max (string[] a, string b);
string[] max (string[] a, string[] b);
string[] min (string a, string[] b);
string[] min (string[] a, string b);
string[] min (string[] a, string[] b);
string[] operator cast (file);
string[] reverse (string[] a);
string[] sequence (string f(int), int n);
string[] sort (string[] a);
string[] sort (string[] a, bool less(string, string));
string[] split (string s, string delimiter=<default>);
string[][] array (int n, string[] value, int depth=<default>);
string[][] copy (string[][] a, int depth=<default>);
string[][] map (string[] f(string[]), string[][] a);
string[][] operator cast (file);
string[][] sequence (string[] f(int), int n);
string[][] sort (string[][] a);
string[][] sort (string[][] a, bool less(string[], string[]));
string[][] transpose (string[][] a);
string[][][] operator cast (file);
surface bispline (real[][] z, real[][] p, real[][] q, real[][] r, real[] x, real[] y, bool[][] cond=<default>);
surface labelpath (string s, path3 p, real angle=<default>, triple optional=<default>);
surface surface (real f(pair z), pair a, pair b, int nx=<default>, int ny=<default>, bool cond(pair z)=<default>);
surface surface (real f(pair z), pair a, pair b, int nx=<default>, int ny=<default>, real[] xsplinetype(real[], real[]), real[] ysplinetype(real[], real[])=<default>, bool cond(pair z)=<default>);
surface surface (real[][] f, pair a, pair b, bool[][] cond=<default>);
surface surface (real[][] f, pair a, pair b, real[] xsplinetype(real[], real[]), real[] ysplinetype(real[], real[])=<default>, bool[][] cond=<default>);
surface surface (real[][] f, real[] x, real[] y, real[] xsplinetype(real[], real[])=<default>, real[] ysplinetype(real[], real[])=<default>, bool[][] cond=<default>);
surface surface (revolution r, int n=<default>, pen color(int i, real j)=<default>);
surface surface (rmf[] R, real[] t, coloredpath cp, transform T(real), bool cyclic);
surface surface (triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, bool cond(pair z)=<default>);
surface surface (triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, real[](real[], real[])[] usplinetype, real[](real[], real[])[] vsplinetype=<default>, bool cond(pair z)=<default>);
surface surface (triple[][] f, bool[][] cond=<default>);
surface surface (vertex[][] g);
surface tube (path3 g, coloredpath section, transform T(real)=<default>, real corner=<default>, real relstep=<default>);
Syzygy operator init ();
tensionSpecifier operator tension (real t, bool atLeast);
tensionSpecifier operator tension (real tout, real tin, bool atleast);
tensionSpecifier tensionSpecifier (guide g, int t);
ticklocate operator init ();
ticklocate ticklocate (real a, real b, autoscaleT S=<default>, real tickmin=<default>, real tickmax=<default>, real time(real)=<default>, pair dir(real)=<default>);
ticklocate ticklocate (real a, real b, autoscaleT S=<default>, real tickmin=<default>, real tickmax=<default>, real time(real)=<default>, triple dir(real));
ticksgridT InOutTicks ()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
ticksgridT InTicks ()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
ticksgridT operator init ();
ticksgridT OutTicks ()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
tickvalues Break (tickvalues)(real, real);
tickvalues generateticks (int sign, Label F=<default>, string ticklabel(real)=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, real Size=<default>, real size=<default>, transform T, pair side, path g, real limit, pen p, ticklocate locate, int[] divisor, bool opposite);
tickvalues None (tickvalues v);
tickvalues NoZero (tickvalues);
tickvalues OmitTick (tickvalues)(... real[] x);
tickvalues OmitTickInterval (tickvalues)(real a, real b);
tickvalues OmitTickIntervals (tickvalues)(real[] a, real[] b);
tickvalues operator init ();
transform fixedscaling (picture pic=<default>, pair min, pair max, pen p=<default>, bool warn=<default>);
transform hprojection (line l, bool safe=<default>);
transform identity ();
transform inverse (transform t);
transform invert;
transform operator * (transform a, transform b);
transform operator + (transform a, transform b);
transform operator init ();
transform operator tuple (real x, real y, real xx, real xy, real yx, real yy);
transform operator ^ (transform t, int n);
transform projection (line l);
transform projection (line l1, line l2, bool safe=<default>);
transform projection (point A, point B);
transform projection (point A, point B, point C, point D, bool safe=<default>);
transform reflect (line l);
transform reflect (line l1, line l2, bool safe=<default>);
transform reflect (pair a, pair b);
transform rotate (explicit pair dir);
transform rotate (explicit point dir);
transform rotate (explicit vector dir);
transform rotate (real angle, pair z=<default>);
transform Rotate (transform t);
transform Rotate (transform)(pair z);
transform rotateO (real a);
transform rotation (transform t);
transform scale (real k, line l1, line l2, bool safe=<default>);
transform scale (real k, point A, point B, point C, point D, bool safe=<default>);
transform scale (real k, point M);
transform scale (real x);
transform scale (real x, real y);
transform Scale (transform t);
transform scaleless (transform t);
transform scaleO (real x);
transform shift (frame f, pair align);
transform shift (pair z);
transform shift (real x, real y);
transform Shift (transform t);
transform shift (transform t);
transform shiftless (transform t);
transform slant (real s);
transform Slant (transform t);
transform swap;
transform tinv;
transform transform (pen p);
transform vprojection (line l, bool safe=<default>);
transform xscale (real k, point M);
transform xscale (real x);
transform xscaleO (real x);
transform yscale (real k, point M);
transform yscale (real y);
transform yscaleO (real x);
transformation operator init ();
transformation transformation (real[][] modelview);
transformation transformation (real[][] modelview, real[][] projection);
tree add (tree t, int key, int value);
tree newtree ();
tree operator init ();
TreeNode makeNode (TreeNode parent=<default>, frame f);
TreeNode makeNode (TreeNode parent=<default>, Label label);
TreeNode operator init ();
tremble operator init ();
triangle anticomplementary (triangle t);
triangle antipedal (triangle t, point M);
triangle cevian (triangle t, point P);
triangle extouch (side side);
triangle extouch (triangle t);
triangle incentral (triangle t);
triangle intouch (triangle t);
triangle isogonal (triangle t, point M);
triangle isotomic (triangle t, point M);
triangle medial (triangle t);
triangle operator * (transform T, triangle t);
triangle operator init ();
triangle orthic (triangle t);
triangle pedal (triangle t, point M);
triangle symmedial (triangle t);
triangle tangential (triangle t);
triangle triangle (line l1, line l2, line l3);
triangle triangleabc (real a, real b, real c, real angle=<default>, point A=<default>);
triangle triangleAbc (real alpha, real b, real c, real angle=<default>, point A=<default>);
triangle[] operator ^^ (... triangle[] t);
triangle[] operator ^^ (triangle[] t1, triangle t2);
trilinear operator init ();
trilinear trilinear (triangle t, point M);
trilinear trilinear (triangle t, real a, real b, real c);
trilinear trilinear (triangle t, real f(real, real, real), real a=<default>, real b=<default>, real c=<default>);
triple accel (path3 p, int t, int sign=<default>);
triple accel (path3 p, real t);
triple bezier (triple a, triple b, triple c, triple d, real t);
triple bezierP (triple a, triple b, triple c, triple d, real t);
triple bezierPP (triple a, triple b, triple c, triple d, real t);
triple bezierPPP (triple a, triple b, triple c, triple d);
triple cross (triple u, triple v);
triple defaultdir (triple X, triple Y, triple Z, bool opposite=<default>, projection P);
triple dir (explicit triple z);
triple dir (path3 p, int t, int sign=<default>, bool normalize=<default>);
triple dir (path3 p, real t, bool normalize=<default>);
triple dir (real colatitude, real longitude);
triple Dir (real)(triple dir);
triple expi (real polar, real azimuth);
triple gettriple (string name=<default>, triple default=<default>, string prompt=<default>, bool store=<default>);
triple interp (triple a, triple b, real t);
triple intersectionpoint (triple n0, triple P0, triple n1, triple P1);
triple max (path3 p);
triple max3 (frame f);
triple max3 (pen p);
triple maxbezier (triple[][] p, triple b);
triple maxbound (triple a, triple b);
triple maxbound (triple[] a);
triple maxbound (triple[][] a);
triple maxbound (triple[][][] a);
triple min (path3 p);
triple min3 (frame f);
triple min3 (pen p);
triple minbezier (triple[][] p, triple b);
triple minbound (triple a, triple b);
triple minbound (triple[] a);
triple minbound (triple[][] a);
triple minbound (triple[][][] a);
triple nextnormal (triple p, triple q);
triple operator * (real x, triple v);
triple operator * (real[][] t, triple v);
triple operator * (triple v, real x);
triple operator + (triple a);
triple operator + (triple a, triple b);
triple operator - (triple a);
triple operator - (triple a, triple b);
triple operator / (triple v, real x);
triple operator cast (file);
triple operator cast (pairOrTriple a);
triple operator ecast (string);
triple operator init ();
triple operator tuple (real x, real y, real z);
triple perp (triple v, triple u);
triple point (path3 p, int t);
triple point (path3 p, real t);
triple polar (real r, real theta, real phi);
triple postcontrol (path3 p, int t);
triple postcontrol (path3 p, real t);
triple precontrol (path3 p, int t);
triple precontrol (path3 p, real t);
triple realmult (triple u, triple v);
triple Scale (picture pic=<default>, triple v);
triple size3 (frame f);
triple sum (triple[] a);
triple ticklabelshift (triple align, pen p=<default>);
triple tickMax3 (picture pic);
triple tickMin3 (picture pic);
triple unit (triple v);
triple X (picture pic);
triple XY (picture pic);
triple Y (picture pic);
triple YZ (picture pic);
triple Z (picture pic);
triple zero3 (real);
triple ZX (picture pic);
triple[] array (int n, triple value, int depth=<default>);
triple[] concat (... triple[][]);
triple[] copy (triple[] a, int depth=<default>);
triple[] firstframe (path3 p, triple optional=<default>);
triple[] map (triple f(triple), triple[] a);
triple[] nextframe (path3 p, real reltimestart, triple[] start, real reltimeend, int subdiv=<default>);
triple[] operator * (real a, triple[] b);
triple[] operator * (triple[] a, real b);
triple[] operator + (triple a, triple[] b);
triple[] operator + (triple[] a);
triple[] operator + (triple[] a, triple b);
triple[] operator + (triple[] a, triple[] b);
triple[] operator - (triple a, triple[] b);
triple[] operator - (triple[] a);
triple[] operator - (triple[] a, triple b);
triple[] operator - (triple[] a, triple[] b);
triple[] operator / (triple[] a, real b);
triple[] operator cast (file);
triple[] reverse (triple[] a);
triple[] sequence (triple f(int), int n);
triple[] sort (triple[] a, bool less(triple, triple));
triple[][] operator * (real a, triple[][] b);
triple[][] operator * (triple[][] a, real b);
triple[][] operator + (triple[][] a, triple[][] b);
triple[][] operator - (triple[][] a);
triple[][] operator - (triple[][] a, triple[][] b);
triple[][] operator cast (file);
triple[][][] operator cast (file);
vector changecoordsys (coordsys R, vector v);
vector conj (explicit vector u);
vector dir (vertex V);
vector operator * (explicit point M, explicit vector v);
vector operator * (real x, explicit vector v);
vector operator * (transform t, explicit vector v);
vector operator + (explicit vector v1, explicit vector v2);
vector operator - (explicit vector v);
vector operator - (explicit vector v1, explicit vector v2);
vector operator / (explicit vector v, real x);
vector operator cast (explicit point v);
vector operator cast (pair v);
vector operator init ();
vector unit (point M);
vector unit (vector u);
vector vector (coordsys R=<default>, pair v);
vector vector (point M);
version version;
vertex operator init ();
vertex opposite (side side);
vertex[][] contour3 (real f(real, real, real), triple a, triple b, int nx=<default>, int ny=<default>, int nz=<default>, projection P=<default>);
vertex[][] contour3 (real[][][] f, real[][][] midpoint=<default>, triple a, triple b, projection P=<default>);
vertex[][] contour3 (triple[][][] v, real[][][] f, real[][][] midpoint=<default>, projection P=<default>);
void abort (string s=<default>);
void activatequote (picture pic=<default>);
void add (frame dest, frame src);
void add (frame dest, frame src, bool group, filltype filltype=<default>, bool above=<default>);
void add (frame dest, frame src, filltype filltype, bool above=<default>);
void add (frame dest, frame src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (frame dest, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (frame f, transform t=<default>, Label L);
void add (picture dest, picture src, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture dest, picture src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture dest=<default>, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture dest=<default>, frame src, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture dest=<default>, object F, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture pic=<default>, face[] faces, projection P=<default>);
void add (picture pic=<default>, Label L);
void add (picture pic=<default>, void d(frame f, real[][] t, picture pic, projection P), bool exact=<default>);
void add (picture pic=<default>, void d(frame f, transform t), bool exact=<default>);
void add (picture pic=<default>, void d(picture, real[][]), bool exact=<default>);
void add (picture pic=<default>, void d(picture, transform), bool exact=<default>);
void add (picture src, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (picture src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void add (string name, picture pic, pair lb=<default>, pair rt=<default>);
void add (TreeNode child, TreeNode parent);
void addArrow (picture pic, arrowhead arrowhead, path g, pen p, real size, real angle, filltype filltype, real position);
void addMargins (picture pic=<default>, real lmargin=<default>, real bmargin=<default>, real rmargin=<default>, real tmargin=<default>, bool rigid=<default>, bool allObject=<default>);
void addSaveFunction (void s()());
void addseg (pair[][] gds, segment seg);
void annotate (picture pic=<default>, string title, string text, pair position);
void arrow (picture pic=<default>, Label L=<default>, pair b, pair dir, real length=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
void assert (bool b, string s=<default>);
void asy (string format, bool overwrite=<default> ... string[] s);
void asycode (bool center=<default>, string s, string options=<default>, string caption=<default>, string preamble=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>, bool newslide=<default>);
void asyfigure (string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, filltype filltype=<default>, bool newslide=<default>);
void asyfilecode (bool center=<default>, string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>, bool newslide=<default>);
void asyinclude (string s, real xsize=<default>, real ysize=<default>);
void atbreakpoint (string f(string, int, int, code));
void atexit ()();
void atexit (void f());
void attach (picture dest=<default>, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void attach (picture dest=<default>, frame src, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
void atupdate ()();
void atupdate (void f());
void autoscale (picture pic=<default>, void axis(picture, axisT));
void autoscale3 (picture pic=<default>, void axis(picture, axisT));
void axes (picture pic=<default>, Label xlabel=<default>, Label ylabel=<default>, bool extend=<default>, pair min=<default>, pair max=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
void axes3 (picture pic=<default>, Label xlabel=<default>, Label ylabel=<default>, Label zlabel=<default>, bool extend=<default>, triple min=<default>, triple max=<default>, pen p=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>);
void axialshade (frame f, path[] g, bool stroke=<default>, pen pena, pair a, bool extenda=<default>, pen penb, pair b, bool extendb=<default>, bool copy=<default>);
void axialshade (picture pic=<default>, path[] g, bool stroke=<default>, pen pena, pair a, bool extenda=<default>, pen penb, pair b, bool extendb=<default>, bool copy=<default>);
void axis (picture pic=<default>, Label L=<default>, path g, path g2=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>), ticklocate locate, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, int[] divisor=<default>, bool above=<default>, bool opposite=<default>);
void axis (picture pic=<default>, Label L=<default>, path3 g, path3 g2=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>), ticklocate locate, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, int[] divisor=<default>, bool above=<default>, bool opposite=<default>);
void babel (string s);
void background ();
void bar (picture pic, pair a, pair d, pen p=<default>);
void beep ();
void begin (picture pic=<default>, string name, string id=<default>, bool visible=<default>);
void beginclip (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
void beginclip (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
void begingroup (frame f);
void begingroup (picture pic=<default>);
void bibliography (string name);
void bibliographystyle (string name);
void Bottom (picture, axisT)(bool extend=<default>);
void Bottom (picture, axisT);
void BottomTop (picture, axisT)(bool extend=<default>);
void BottomTop (picture, axisT);
void Bounds (picture, axisT)(int type=<default>, int type2=<default>, triple align=<default>, bool extend=<default>);
void Bounds (picture, axisT);
void breakpoint (code s=<default>);
void breakpoints ();
void buildRestoreDefaults ()();
void buildRestoreThunk ()();
void center (string s, pen p=<default>);
void checkconditionlength (int x, int y);
void checkincreasing (real[] x);
void checklengths (int x, int y, string text=<default>);
void clear ();
void clear (file f);
void clear (string file, int line);
void clear (string file, string text);
void clip (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
void clip (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
void clipdraw (picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, real xmargin=<default>, real ymargin=<default>, Label legend=<default>, marker marker=<default>);
void close (file f);
void code (bool center=<default>, string s, pen p=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>);
void collect (pair[][][] points, real[] c);
void color (string name, string color);
void comma (file file);
void connect (path[] paths, path[] result, path[] patch);
void copyPairOrTriple (pairOrTriple dest, pairOrTriple src);
void crop (picture pic=<default>);
void currentexitfunction ();
void deactivatequote (picture pic=<default>);
void deconstruct (frame f, frame preamble=<default>, real magnification=<default>, transform xform());
void deconstruct (picture pic=<default>, real magnification=<default>);
void defaultpen (pen p);
void defaultpen (real w);
void deletepreamble ();
void display (frame f, real margin=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void display (frame[] f, real margin=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void display (string s, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void display (string[] s, real margin=<default>, string[] captions=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void distance (picture pic=<default>, Label L=<default>, point A, point B, bool rotated=<default>, real offset=<default>, pen p=<default>, pen joinpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
void DOSendl (file file);
void DOSnewl (file file);
void dot (frame f, pair z, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, Label L, explicit mass M, align align=<default>, string format=<default>, pen p=<default>);
void dot (picture pic=<default>, Label L, explicit point Z, align align=<default>, string format=<default>, pen p=<default>);
void dot (picture pic=<default>, Label L, pair z, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, Label L, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, Label[] L=<default>, explicit path g, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, Label[] L=<default>, pair[] z, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, pair z, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, path[] g, pen p=<default>, filltype filltype=<default>);
void dot (picture pic=<default>, triangle t, pen p=<default>);
void do_overpaint (picture pic, path p, pen bgpen, real halfwidth, real vertexangle);
void draw (frame f, explicit path[] g, pen p=<default>);
void draw (frame f, guide[] g, pen p=<default>);
void draw (frame f, path g, pen p=<default>);
void draw (frame f, path g, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen)));
void draw (frame f, triple[] p, real[] knot, real[] weights=<default>, pen p);
void draw (frame f, triple[] v, int[][] vi, triple[] n, int[][] ni, pen[] p, real opacity, real shininess, real prcshininess, pen[] c=<default>, int[][] ci=<default>);
void draw (frame f, triple[][] p, real[] uknot, real[] vknot, real[][] weights=<default>, pen[] p, real opacity, real shininess, real prcshininess, pen[] colors);
void draw (frame f, triple[][] p, triple center, bool straight, pen[] p, real opacity, real shininess, real prcshininess, triple normal, pen[] colors, int interaction, bool prc=<default>);
void draw (pair origin, picture pic=<default>, explicit path[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
void draw (pair origin, picture pic=<default>, guide[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
void draw (pair origin, picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, binarytree tree, real minDist=<default>, real nodeMargin=<default>, pen p=<default>, bool condensed=<default>);
void draw (picture pic=<default>, block block, pen p=<default>);
void Draw (picture pic=<default>, explicit path[] g, pen p=<default>);
void draw (picture pic=<default>, explicit path[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, guide[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, arc a, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, circle c, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, ellipse el, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, explicit conic co, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, hyperbola h, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, line l, bool dirA=<default>, bool dirB=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
void draw (picture pic=<default>, Label L=<default>, parabola parabola, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
void draw (picture pic=<default>, Label[] L=<default>, guide[][] g, pen p=<default>);
void draw (picture pic=<default>, Label[] L=<default>, guide[][] g, pen[] p);
void draw (picture pic=<default>, Label[] L=<default>, line[] l, align align=<default>, pen p, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label[] legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
void draw (picture pic=<default>, Label[] L=<default>, line[] l, align align=<default>, pen[] p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label[] legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
void draw (picture pic=<default>, Label[] L=<default>, void(flatguide3)[][] g, pen p=<default>, light light=<default>, string name=<default>, render render=<default>, interaction interaction=<default>);
void draw (picture pic=<default>, Label[] L=<default>, void(flatguide3)[][] g, pen[] p, light light=<default>, string name=<default>, render render=<default>, interaction interaction=<default>);
void draw (picture pic=<default>, obj o, light light=<default>);
void Draw (picture pic=<default>, path g, pen p=<default>);
void draw (picture pic=<default>, path[] g, pen fillrule=<default>, pen[] p);
void draw (picture pic=<default>, revolution r, int m=<default>, int n=<default>, pen frontpen=<default>, pen backpen=<default>, pen longitudinalpen=<default>, pen longitudinalbackpen=<default>, light light=<default>, string name=<default>, render render=<default>, projection P=<default>);
void draw (picture pic=<default>, triangle t, pen p=<default>, marker marker=<default>);
void draw (picture pic=<default>, triangle[] t, pen p=<default>, marker marker=<default>);
void draw (TreeNode root, pair pos);
void drawAll (TreeNode node, frame f);
void drawarrow (frame f, arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>, bool forwards=<default>, marginT margin(path, pen)=<default>, bool center=<default>);
void drawarrow2 (frame f, arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>);
void drawDoubleLine (picture pic=<default>, path p, pen fgpen=<default>, real dlspacing=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void drawFermion (picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void drawGhost (picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void drawGluon (picture pic=<default>, path p, real amp=<default>, real width=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void Drawline (picture pic=<default>, Label L=<default>, pair P, bool dirP=<default>, pair Q, bool dirQ=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
void drawline (picture pic=<default>, pair P, pair Q, pen p=<default>);
void drawline (picture pic=<default>, triangle t, pen p=<default>);
void drawMomArrow (picture pic=<default>, path p, align align, position pos=<default>, real offset=<default>, real length=<default>, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real margin=<default>);
void drawPhoton (picture pic=<default>, path p, real amp=<default>, real width=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void drawpixel (frame f, triple v, pen p, real width=<default>);
void drawPRCcylinder (frame f, real[][] t, pen[] p, real opacity, real shininess);
void drawPRCdisk (frame f, real[][] t, pen[] p, real opacity, real shininess);
void drawPRCsphere (frame f, real[][] t, bool half=<default>, pen[] p, real opacity, real shininess, int type);
void drawPRCtube (frame f, path3 center, path3 g, pen[] p, real opacity, real shininess);
void drawScalar (picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
void drawtick (frame f, transform T, path g, path g2, ticklocate locate, real val, real Size, int sign, pen p, bool extend);
void drawtick (picture pic, real[][] T, path3 g, path3 g2, ticklocate locate, real val, real Size, int sign, pen p, bool extend);
void drawVertex (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
void drawVertexBox (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
void drawVertexBoxO (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
void drawVertexBoxX (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
void drawVertexO (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
void drawVertexOX (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
void drawVertexTriangle (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
void drawVertexTriangleO (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
void drawVertexX (picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
void end (picture pic=<default>);
void endclip (frame f);
void endclip (picture pic=<default>);
void endgroup (frame f);
void endgroup (picture pic=<default>);
void endgroup3 (frame f);
void endl (file file);
void endScript ();
void equation (string s, pen p=<default>);
void equations (string s, pen p=<default>);
void erase (frame f);
void erase (picture pic=<default>);
void erasestep (int erasenode);
void errorbar (picture pic, pair z, pair dp, pair dm, pen p=<default>, real size=<default>);
void errorbars (picture pic=<default>, pair[] z, pair[] dp, pair[] dm=<default>, bool[] cond=<default>, pen p=<default>, real size=<default>);
void errorbars (picture pic=<default>, real[] x, real[] y, real[] dpx, real[] dpy, real[] dmx=<default>, real[] dmy=<default>, bool[] cond=<default>, pen p=<default>, real size=<default>);
void errorbars (picture pic=<default>, real[] x, real[] y, real[] dpy, bool[] cond=<default>, pen p=<default>, real size=<default>);
void eval (code s, bool embedded=<default>);
void eval (string s, bool embedded=<default>);
void exit ();
void exitfunction ();
void exitfunction ();
void exitXasyMode ();
void expfactors (real x, coefficients a);
void figure (string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void figure (string[] s, string options=<default>, real margin=<default>, string[] captions=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
void filecode (bool center=<default>, string s, pen p=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>);
void fill (frame f, path[] g, pen p=<default>, bool copy=<default>);
void fill (pair origin, picture pic=<default>, path[] g, pen p=<default>);
void fill (picture pic=<default>, guide[][] g, pen[][] palette);
void fill (picture pic=<default>, path[] g, pen p=<default>, bool copy=<default>);
void filldraw (frame f, path[] g, pen fillpen=<default>, pen drawpen=<default>);
void filldraw (picture pic=<default>, path[] g, pen fillpen=<default>, pen drawpen=<default>);
void filloutside (frame f, path[] g, pen p=<default>, bool copy=<default>);
void filloutside (picture pic=<default>, path[] g, pen p=<default>, bool copy=<default>);
void flush (file f);
void fmdefaults ();
void functionshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, string shader=<default>, bool copy=<default>);
void functionshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, string shader, bool copy=<default>);
void generate_random_backtrace ();
void gouraudshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, int[] edges, bool copy=<default>);
void gouraudshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, pair[] z, int[] edges, bool copy=<default>);
void gouraudshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, int[] edges, bool copy=<default>);
void gouraudshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, pair[] z, int[] edges, bool copy=<default>);
void graph (flatguide3)(picture pic=<default>, real f(pair), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(picture pic=<default>, real x(real), real y(real), real z(real), real a, real b, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(picture pic=<default>, real[] x, real[] y, real[] z, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(picture pic=<default>, triple v(real), real a, real b, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(picture pic=<default>, triple[] v, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(real f(pair), path p, int n=<default>, real T(pair), void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(triple F(pair), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(triple F(path, real), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void graph (flatguide3)(triple F(real), real, real, int)(void join(flatguide3)(... void(flatguide3)[]));
void grestore (frame f);
void grestore (picture pic=<default>);
void grid3 (picture pic=<default>, grid3(picture pic)[][] gridroutine, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, pen[] pGrid, pen[] pgrid, bool above=<default>);
void grid3 (picture pic=<default>, grid3(picture pic)[][] gridroutine=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, pen pGrid=<default>, pen pgrid=<default>, bool above=<default>);
void gsave (frame f);
void gsave (picture pic=<default>);
void histogram (picture pic=<default>, real[] bins, real[] count, real low=<default>, pen fillpen=<default>, pen drawpen=<default>, bool bars=<default>, Label legend=<default>, real markersize=<default>);
void histogram (picture pic=<default>, real[] data, real a, real b, int n, bool normalize=<default>, real low=<default>, pen fillpen=<default>, pen drawpen=<default>, bool bars=<default>, Label legend=<default>, real markersize=<default>);
void image (frame f, pen[][] data, pair initial, pair final, bool transpose=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
void image (frame f, real[][] data, pair initial, pair final, pen[] palette, bool transpose=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
void image (picture pic=<default>, pen f(int, int), int width, int height, pair initial, pair final, bool transpose=<default>, bool antialias=<default>);
void image (picture pic=<default>, pen[][] data, pair initial, pair final, bool transpose=<default>, bool copy=<default>, bool antialias=<default>);
void incrementposition (pair z);
void indexedfigure (string prefix, int first, int last, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool step=<default>);
void initdefaults ();
void initXasyMode ();
void InOutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void InOutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void InOutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
void InTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void InTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void InTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
void item (string s, pen p=<default>, bool step=<default>);
void label (frame f, Label L, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (frame f, Label L, pair position, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (frame f, string s, string size, transform t, pair position, pair align, pen p);
void label (picture pic, Label L, pair z, real x, align align, string format, pen p);
void label (picture pic, Label L, triple v, real x, align align, string format, pen p);
void label (picture pic=<default>, Label L, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label L, explicit guide g, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label L, explicit mass M, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label L, explicit path g, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label L, pair position, align align=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label L, vertex V, pair align=<default>, real alignFactor=<default>, pen p=<default>, filltype filltype=<default>);
void label (picture pic=<default>, Label LA=<default>, Label LB=<default>, Label LC=<default>, triangle t, real alignAngle=<default>, real alignFactor=<default>, pen p=<default>, filltype filltype=<default>);
void labelaxis (frame f, transform T, Label L, path g, ticklocate locate=<default>, int sign=<default>, bool ticklabels=<default>);
void labelaxis (picture pic, real[][] T, Label L, path3 g, ticklocate locate=<default>, int sign=<default>, bool ticklabels=<default>);
void labelpath (frame f, Label L, path g, string justify=<default>, pen p=<default>);
void labelpath (picture pic=<default>, Label L, path g, string justify=<default>, pen p=<default>);
void labeltick (picture pic, real[][] T, path3 g, ticklocate locate, real val, int sign, real Size, string ticklabel(real), Label F, real norm=<default>);
void labelx (picture pic=<default>, Label L, string format=<default>, explicit pen p=<default>);
void labelx (picture pic=<default>, Label L=<default>, explicit pair z, align align=<default>, string format=<default>, pen p=<default>);
void labelx (picture pic=<default>, Label L=<default>, real x, align align=<default>, string format=<default>, pen p=<default>);
void labelx (picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
void labelx3 (picture pic=<default>, Label L=<default>, real x, align align=<default>, string format=<default>, pen p=<default>);
void labely (picture pic=<default>, Label L, string format=<default>, explicit pen p=<default>);
void labely (picture pic=<default>, Label L=<default>, explicit pair z, align align=<default>, string format=<default>, pen p=<default>);
void labely (picture pic=<default>, Label L=<default>, real y, align align=<default>, string format=<default>, pen p=<default>);
void labely (picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
void labely3 (picture pic=<default>, Label L=<default>, real y, align align=<default>, string format=<default>, pen p=<default>);
void labelz (picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
void labelz3 (picture pic=<default>, Label L=<default>, real z, align align=<default>, string format=<default>, pen p=<default>);
void latticeshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, transform t=<default>, bool copy=<default>);
void latticeshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, bool copy=<default>);
void layer (frame f);
void layer (picture pic=<default>);
void Left (picture, axisT)(bool extend=<default>);
void Left (picture, axisT);
void LeftRight (picture, axisT)(bool extend=<default>);
void LeftRight (picture, axisT);
void LeftTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void LeftTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void LeftTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
void limits (picture pic=<default>, pair min, pair max, bool crop=<default>);
void limits (picture pic=<default>, triple min, triple max);
void lineinversion ();
void list (string s, bool imports=<default>);
void lm_evaluate_default (real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info);
void lm_lmdif (int m, int n, real[] x, real[] fvec, real ftol, real xtol, real gtol, int maxfev, real epsfcn, real[] diag, int mode, real factor, lm_int_type info, lm_int_type nfev, real[] fjac, int[] ipvt, real[] qtf, real[] wa1, real[] wa2, real[] wa3, real[] wa4, void evaluate(real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info), void printout(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev), lm_data_type data);
void lm_lmpar (int n, real[] r, int ldr, int[] ipvt, real[] diag, real[] qtb, real delta, lm_real_type par, real[] x, real[] sdiag, real[] wa1, real[] wa2);
void lm_minimize (int m_dat, int n_par, real[] par, void evaluate(real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info), void printout(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev), lm_data_type data, lm_control_type control);
void lm_print_default (int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev);
void lm_print_quiet (int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev);
void lm_qrfac (int m, int n, real[] a, bool pivot, int[] ipvt, real[] rdiag, real[] acnorm, real[] wa);
void lm_qrsolv (int n, real[] r, int ldr, int[] ipvt, real[] diag, real[] qtb, real[] x, real[] sdiag, real[] wa);
void makedraw (frame f, path g, pen p, int depth=<default>);
void markangle (picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, explicit line l1, explicit line l2, explicit pair align=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
void markangle (picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, explicit line l1, explicit line l2, explicit vector align, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
void markangle (picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, pair A, pair O, pair B, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
void markarc (picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, arc a, pen sectorpen=<default>, pen markpen=<default>, marginT margin(path, pen)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marker marker=<default>);
void markinterval (picture pic=<default>, frame f, path g)(int n=<default>, frame f, bool rotated=<default>);
void marknodes (picture pic=<default>, frame f, path g);
void markrightangle (picture pic=<default>, point A, point O, point B, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void markuniform (picture pic=<default>, frame f, path g)(bool centered=<default>, int n, bool rotated=<default>);
void markuniform (picture pic=<default>, frame f, path g)(pair z(real t), real a, real b, int n);
void multifigure (string[] slist, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool step=<default>);
void newl (file file);
void newpage (frame f);
void newpage (picture pic=<default>);
void newslide (bool stepping=<default>);
void nextpage (pen p=<default>);
void none (file file);
void normalvideo ();
void NoTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)();
void NoTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
void NoTicks3 (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)();
void NoTicks3 (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
void nowarn (string s);
void numberpage (pen p=<default>);
void outline (string s=<default>, pair position=<default>, pair align=<default>, pen p=<default>);
void OutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void OutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void OutTicks (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
void overloadedMessage (file file);
void palette (picture pic=<default>, Label L=<default>, bounds bounds, pair initial, pair final, void axis(picture, axisT)=<default>, pen[] palette, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>)=<default>, bool copy=<default>, bool antialias=<default>);
void PaletteTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, pen pTick=<default>, pen ptick=<default>);
void PaletteTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>);
void pause (string w=<default>);
void perpendicular (picture pic=<default>, pair z, pair align, pair dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicular (picture pic=<default>, pair z, pair align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicularmark (picture pic=<default>, line l1, line l2, real size=<default>, pen p=<default>, int quarter=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicularmark (picture pic=<default>, point z, explicit pair align, explicit pair dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicularmark (picture pic=<default>, point z, explicit pair align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicularmark (picture pic=<default>, point z, vector align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void perpendicularmark (picture pic=<default>, point z, vector align, vector dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
void polargraph (flatguide3)(real r(real, real), real theta(real), real phi(real), int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
void postscript (frame f, string s);
void postscript (frame f, string s, pair min, pair max);
void postscript (picture pic=<default>, string s);
void postscript (picture pic=<default>, string s, pair min, pair max);
void prepend (frame dest, frame src);
void printBytecode (<open>);
void print_random_addresses (int n=<default>);
void purge (int divisor=<default>);
void radialshade (frame f, path[] g, bool stroke=<default>, pen pena, pair a, real ra, bool extenda=<default>, pen penb, pair b, real rb, bool extendb=<default>, bool copy=<default>);
void radialshade (picture pic=<default>, path[] g, bool stroke=<default>, pen pena, pair a, real ra, bool extenda=<default>, pen penb, pair b, real rb, bool extendb=<default>, bool copy=<default>);
void remark (bool center=<default>, string s, pair align=<default>, pen p=<default>, real indent=<default>, bool minipage=<default>, real skip=<default>, filltype filltype=<default>, bool step=<default>);
void report (int i);
void report (real old, real h, real t);
void report (string text);
void report (transform t);
void resetdefaultpen ();
void restore ();
void restoredefaults ();
void reversevideo ();
void Right (picture, axisT)(bool extend=<default>);
void Right (picture, axisT);
void RightTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void RightTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void RightTicks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
void save ()();
void savedefaults ()();
void saveline (string name, string value, bool store=<default>);
void scale (picture pic=<default>, bool xautoscale=<default>, bool yautoscale=<default>, bool zautoscale=<default>);
void scale (picture pic=<default>, scaleT x, scaleT y=<default>, scaleT z=<default>);
void seek (file f, int pos);
void seekeof (file f);
void setpens (pen red=<default>, pen blue=<default>, pen steppen=<default>);
void shipout (string prefix=<default>, frame f, frame preamble=<default>, string format=<default>, bool wait=<default>, bool view=<default>, transform xform());
void shipout (string prefix=<default>, frame f, string format=<default>, bool wait=<default>, bool view=<default>, string options=<default>, string script=<default>, light light=<default>, projection P=<default>);
void shipout (string prefix=<default>, picture pic=<default>, frame orientation(frame)=<default>, string format=<default>, bool wait=<default>, bool view=<default>, string options=<default>, string script=<default>, light light=<default>, projection P=<default>);
void shipout3 (string prefix, frame f);
void shipout3 (string prefix, frame f, string format=<default>, real width, real height, real angle, real zoom, triple m, triple m, pair shift, real[][] t, real[] background, triple[] lights, real[][] diffuse, real[][] ambient, real[][] specular, bool viewportlighting, bool view=<default>);
void show (Label L, vector v, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
void show (picture pic=<default>, Label LA=<default>, Label LB=<default>, Label LC=<default>, Label La=<default>, Label Lb=<default>, Label Lc=<default>, triangle t, pen p=<default>, filltype filltype=<default>);
void show (picture pic=<default>, Label lo=<default>, Label li=<default>, Label lj=<default>, coordsys R, pen dotpen=<default>, pen xpen=<default>, pen ypen=<default>, pen ipen=<default>, pen jpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
void show (picture pic=<default>, line l, pen p=<default>);
void size (picture dest, picture src);
void size (picture pic=<default>, real x, real y=<default>, bool keepAspect=<default>);
void size (picture pic=<default>, real xsize, real ysize, pair min, pair max);
void size3 (picture pic=<default>, real x, real y=<default>, real z=<default>, bool keepAspect=<default>);
void skip (real n=<default>);
void sleep (int seconds);
void Spline (flatguide3)(... void(flatguide3)[]);
void srand (int seed);
void startScript ();
void step ();
void stop (string file, int line, code s=<default>);
void stop (string file, string text, code s=<default>);
void Straight (flatguide3)(... void(flatguide3)[]);
void subitem (string s, pen p=<default>);
void tab (file file);
void tensorshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>);
void tensorshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>, pair[] z);
void tensorshade (frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, path[] b=<default>, pair[][] z=<default>, bool copy=<default>);
void tensorshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>);
void tensorshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>, pair[] z);
void tensorshade (picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, path[] b=<default>, pair[][] z=<default>, bool copy=<default>);
void tex (frame f, string s);
void tex (frame f, string s, pair min, pair max);
void tex (picture pic=<default>, string s);
void tex (picture pic=<default>, string s, pair min, pair max);
void texpreamble (string s);
void texreset ();
void texshipout (string stem, picture pic=<default>, bool xalign=<default>);
void tick (picture pic=<default>, Label L, real value, explicit pair z, pair dir, string format=<default>, real size=<default>, pen p=<default>);
void tick (picture pic=<default>, Label L, real value, triple v, triple dir, string format=<default>, real size=<default>, pen p=<default>);
void tick (picture pic=<default>, pair z, pair dir, real size=<default>, pen p=<default>);
void tick (picture pic=<default>, triple v, triple dir, real size=<default>, pen p=<default>);
void Ticks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void Ticks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks=<default>, real[] ticks=<default>, int N=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void Ticks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void Ticks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void Ticks (frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
void Ticks3 (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void Ticks3 (picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks=<default>, real[] ticks=<default>, int N=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
void title (string s, pair position=<default>, pair align=<default>, pen p=<default>, bool newslide=<default>);
void titlepage (string title, string author, string institution=<default>, string date=<default>, string url=<default>, bool newslide=<default>);
void Top (picture, axisT)(bool extend=<default>);
void Top (picture, axisT);
void unfill (frame f, path[] g, bool copy=<default>);
void unfill (picture pic=<default>, path[] g, bool copy=<default>);
void unitsize (picture pic=<default>, real x, real y=<default>, real z=<default>);
void updatefunction ();
void usepackage (string s, string options=<default>);
void usersetting ();
void usersetting ();
void usetypescript (string s, string encoding=<default>);
void usleep (int microseconds);
void vbox (string s, pen p=<default>);
void warn (string s);
void warning (string s, string t, bool position=<default>);
void write (explicit line l);
void write (explicit segment s);
void write (file file, string s=<default>, bool3 b, void suffix(file)=<default>);
void write (file file, string s=<default>, cputime c, string format=<default>, void suffix(file)=<default>);
void write (file file, string s=<default>, explicit guide[] x, void suffix(file)=<default>);
void write (file file, string s=<default>, explicit path[] x, void suffix(file)=<default>);
void write (file file, void suffix(file)=<default>);
void write (file file=<default>, align align, void suffix(file)=<default>);
void write (file file=<default>, bool[][]);
void write (file file=<default>, bool[][][]);
void write (file file=<default>, int[][]);
void write (file file=<default>, int[][][]);
void write (file file=<default>, Label L, void suffix(file)=<default>);
void write (file file=<default>, pair[][]);
void write (file file=<default>, pair[][][]);
void write (file file=<default>, real[][]);
void write (file file=<default>, real[][][]);
void write (file file=<default>, string s, void suffix(file)=<default>);
void write (file file=<default>, string s=<default>, bool x, void suffix(file)=<default> ... bool[]);
void write (file file=<default>, string s=<default>, explicit bool[] a ... bool[][]);
void write (file file=<default>, string s=<default>, explicit int[] a ... int[][]);
void write (file file=<default>, string s=<default>, explicit pair[] a ... pair[][]);
void write (file file=<default>, string s=<default>, explicit real[] a ... real[][]);
void write (file file=<default>, string s=<default>, explicit string[] a ... string[][]);
void write (file file=<default>, string s=<default>, explicit triple[] a ... triple[][]);
void write (file file=<default>, string s=<default>, guide x, void suffix(file)=<default> ... guide[]);
void write (file file=<default>, string s=<default>, int x, void suffix(file)=<default> ... int[]);
void write (file file=<default>, string s=<default>, pair x, void suffix(file)=<default> ... pair[]);
void write (file file=<default>, string s=<default>, pen x, void suffix(file)=<default> ... pen[]);
void write (file file=<default>, string s=<default>, pen[] p);
void write (file file=<default>, string s=<default>, real x, void suffix(file)=<default> ... real[]);
void write (file file=<default>, string s=<default>, string x, void suffix(file)=<default> ... string[]);
void write (file file=<default>, string s=<default>, transform x, void suffix(file)=<default> ... transform[]);
void write (file file=<default>, string s=<default>, triple x, void suffix(file)=<default> ... triple[]);
void write (file file=<default>, string[][]);
void write (file file=<default>, string[][][]);
void write (file file=<default>, triple[][]);
void write (file file=<default>, triple[][][]);
void write (file out=<default>, tree t);
void write (pairOrTriple a);
void write (solution S);
void write (Solution S);
void write (string s=<default>, bool3 b, void suffix(file)=<default>);
void write (string s=<default>, cputime c, string format=<default>, void suffix(file)=<default>);
void write (string s=<default>, explicit guide[] x, void suffix(file)=<default>);
void write (string s=<default>, explicit path[] x, void suffix(file)=<default>);
void write (trilinear tri);
void write (void suffix(file)=<default>);
void xaxis (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
void xaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
void xaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
void xaxis3At (picture pic=<default>, Label L=<default>, void axis(picture, axisT), real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
void xaxisAt (picture pic=<default>, Label L=<default>, void axis(picture, axisT), real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool opposite=<default>);
void xequals (picture pic=<default>, Label L=<default>, real x, bool extend=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
void XEquals (picture, axisT)(real x, bool extend=<default>);
void xlimits (picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
void xtick (picture pic=<default>, explicit pair z, pair dir=<default>, real size=<default>, pen p=<default>);
void xtick (picture pic=<default>, Label L, explicit pair z, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void xtick (picture pic=<default>, Label L, real x, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void xtick (picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void xtick (picture pic=<default>, real x, pair dir=<default>, real size=<default>, pen p=<default>);
void xtick (picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
void xtick3 (picture pic=<default>, Label L, real x, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void xtick3 (picture pic=<default>, real x, triple dir=<default>, real size=<default>, pen p=<default>);
void XYEquals (picture, axisT)(real x, real y, triple align=<default>, bool extend=<default>);
void XYZero (picture, axisT)(triple align=<default>, bool extend=<default>);
void XYZero (picture, axisT);
void XZEquals (picture, axisT)(real x, real z, triple align=<default>, bool extend=<default>);
void XZero (picture, axisT)(bool extend=<default>);
void XZero (picture, axisT);
void XZZero (picture, axisT)(triple align=<default>, bool extend=<default>);
void XZZero (picture, axisT);
void yaxis (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool autorotate=<default>);
void yaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
void yaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
void yaxis3At (picture pic=<default>, Label L=<default>, void axis(picture, axisT), real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
void yaxisAt (picture pic=<default>, Label L=<default>, void axis(picture, axisT), real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool opposite=<default>);
void yequals (picture pic=<default>, Label L=<default>, real y, bool extend=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
void YEquals (picture, axisT)(real y, bool extend=<default>);
void ylimits (picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
void ytick (picture pic=<default>, explicit pair z, pair dir=<default>, real size=<default>, pen p=<default>);
void ytick (picture pic=<default>, Label L, explicit pair z, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ytick (picture pic=<default>, Label L, real y, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ytick (picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ytick (picture pic=<default>, real y, pair dir=<default>, real size=<default>, pen p=<default>);
void ytick (picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
void ytick3 (picture pic=<default>, Label L, real y, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ytick3 (picture pic=<default>, real y, triple dir=<default>, real size=<default>, pen p=<default>);
void YZEquals (picture, axisT)(real y, real z, triple align=<default>, bool extend=<default>);
void YZero (picture, axisT)(bool extend=<default>);
void YZero (picture, axisT);
void YZZero (picture, axisT)(triple align=<default>, bool extend=<default>);
void YZZero (picture, axisT);
void zaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
void zaxis3 (picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real zmin=<default>, real zmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
void zaxis3At (picture pic=<default>, Label L=<default>, void axis(picture, axisT), real zmin=<default>, real zmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
void zlimits (picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
void ztick (picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ztick (picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
void ztick3 (picture pic=<default>, Label L, real z, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
void ztick3 (picture pic=<default>, real z, triple dir=<default>, real size=<default>, pen p=<default>);
void _begingroup3 (frame f, string name, real compression, real granularity, bool closed, bool tessellate, bool dobreak, bool nobreak, triple center, int interaction);
void _draw (frame f, path g, pen p);
void _draw (frame f, path3 g, triple center=<default>, pen p, int interaction=<default>);
void _draw (picture pic, path g, pen p, marginT margin(path, pen));
void _eval (code s, bool embedded);
void _eval (string s, bool embedded, bool interactivewrite=<default>);
void _image (frame f, pen f(int, int), int width, int height, pair initial, pair final, transform t=<default>, bool antialias=<default>);
void _image (frame f, pen[][] data, pair initial, pair final, transform t=<default>, bool copy=<default>, bool antialias=<default>);
void _image (frame f, real[][] data, pair initial, pair final, pen[] palette=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
void _labelpath (frame f, string s, string size, path g, string justify, pair offset, pen p);
void()()[] array (int n, void value()(), int depth=<default>);
void()()[] concat (... void()()[][]);
void()()[] copy (void()()[] a, int depth=<default>);
void()()[] map (void f()()(void()()), void()()[] a);
void()()[] saveFunctions;
void()()[] sequence (void f()()(int), int n);
void()()[] sort (void()()[] a, bool less(void()(), void()()));
void(flatguide3)[] graph (picture pic=<default>, real x(real), real y(real), real z(real), real a, real b, int n=<default>, bool3 cond(real), void join(flatguide3)(... void(flatguide3)[])=<default>);
void(flatguide3)[] graph (picture pic=<default>, real[] x, real[] y, real[] z, bool3[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
void(flatguide3)[] graph (picture pic=<default>, triple v(real), real a, real b, int n=<default>, bool3 cond(real), void join(flatguide3)(... void(flatguide3)[])=<default>);
void(flatguide3)[] graph (picture pic=<default>, triple[] v, bool3[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
void(flatguide3)[] graph (triple F(real), real, real, int)(void join(flatguide3)(... void(flatguide3)[]), bool3 cond(real));
void(flatguide3)[][] lift (real f(pair z), guide[][] g, void join(flatguide3)(... void(flatguide3)[])=<default>);
void(flatguide3)[][] lift (real f(real x, real y), guide[][] g, void join(flatguide3)(... void(flatguide3)[])=<default>);
weighted operator init ();
Type Nom Arguments