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