From 19fc9fd9a26973d87fad437ce549ffaba479df54 Mon Sep 17 00:00:00 2001 From: Karl Berry Date: Thu, 31 May 2012 00:02:26 +0000 Subject: asy 2.16 sources git-svn-id: svn://tug.org/texlive/trunk@26734 c570f23f-e606-0410-a88d-b1316a301751 --- Build/source/utils/asymptote/asy.list | 3753 +++++++++++++++++++++++++++++++++ 1 file changed, 3753 insertions(+) (limited to 'Build/source/utils/asymptote/asy.list') diff --git a/Build/source/utils/asymptote/asy.list b/Build/source/utils/asymptote/asy.list index e69de29bb2d..6e94649b60b 100644 --- a/Build/source/utils/asymptote/asy.list +++ b/Build/source/utils/asymptote/asy.list @@ -0,0 +1,3753 @@ +string stripfile(string s); +string stripsuffix(string f, string suffix=); +real cbrt(real x); +real[] cbrt(real[] a); +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; +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(path3 p, int t); +real straightness(triple z0, triple c0, triple c1, triple z1); +real log10(real x); +real[] log10(real[] a); +pen paleblue; +bool prc0(string format=); +int CTZ(int a); +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); +bool inXasyMode; +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=, bool group=, filltype filltype=, bool above=); +void attach(picture dest=, frame src, pair position, pair align, 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; +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 exitXasyMode(); +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(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))(arrowhead arrowhead=, real size=, real angle=, filltype filltype=); +bool ArcArrows(picture, path, pen, marginT(path, pen)); +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; +void endScript(); +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); +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(path p); +pair min(explicit path[] p); +triple min(path3 p); +real min(... real[] a); +pair min(picture pic, bool user=); +real min(real m, scaling s, coord[] c); +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(object[] a, object key, bool less(object, object)); +int search(real[] a, real key, bool less(real, real)); +int search(guide[] a, guide key, bool less(guide, guide)); +int search(coord[] a, coord key, bool less(coord, coord)); +int search(Label[] a, Label key, bool less(Label, Label)); +int search(pair[] a, pair key, bool less(pair, pair)); +int search(frame[] a, frame key, bool less(frame, frame)); +int search(coord[] a, coord key, bool less(coord, coord)); +int search(int[] a, int key, bool less(int, int)); +int search(bool3[] a, bool3 key, bool less(bool3, bool3)); +int search(picture[] a, picture key, bool less(picture, picture)); +int search(marker[] a, marker key, bool less(marker, marker)); +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(bool[] a, bool key, bool less(bool, bool)); +int search(triple[] a, triple key, bool less(triple, triple)); +int search(Legend[] a, Legend key, bool less(Legend, Legend)); +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=); +int rename(string from, string to); +void DOSendl(file file); +string debugger(string file, int line, int column, code s=); +string getc(file f); +bool debugging; +void shipout(string prefix=, frame f, frame preamble=, string format=, bool wait=, bool view=, transform xform()); +void shipout(string prefix=, frame f, string format=, bool wait=, bool view=, string options=, string script=, light light=, projection P=); +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, real[][] t, real[] background, triple[] lights, real[][] diffuse, real[][] ambient, real[][] specular, bool viewportlighting, bool view=); +void shipout3(string prefix, frame f, int[] index, triple[] center); +string getstring(string name=, string default=, string prompt=, bool store=); +int debuggerlines; +frame bbox(picture pic=, real xmargin=, real ymargin=, pen p=, 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, pen penb, pair b, real rb, bool copy=); +void radialshade(picture pic=, path[] g, bool stroke=, pen pena, pair a, real ra, pen penb, pair b, real rb, 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 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(path p); +pair max(explicit path[] p); +triple max(path3 p); +pair max(picture pic, bool user=); +real max(real M, scaling s, coord[] c); +real max(real M, scaling s, coord[] c); +int max(... int[] a); +real max(... real[] a); +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 L, explicit position position, align align=, pen p=, transform embed(transform)=, filltype filltype=); +Label Label; +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=); +Label Label(string s, string size=, pair position, 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=); +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; +pen squarepen; +bool EndArrow(picture, path, pen, marginT(path, pen)); +bool EndArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=, real size=, real angle=, filltype filltype=, position position=); +real barsize(pen p=); +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); +void tensorshade(frame f, path[] g, bool stroke=, pen fillrule=, pen[] p, path b=); +void tensorshade(picture pic=, path[] g, bool stroke=, pen fillrule=, pen[] p, path b=); +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 label(frame f, string s, string size, transform t, pair position, pair align, pen p); +void label(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=); +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=); +real fabs(real x); +real[] fabs(real[] a); +bool labels(frame f); +light light(pen diffuse=, pen ambient=, pen specular=, pen background=, real specularfactor=, bool viewport= ... triple[] position); +light light(pen[] diffuse, pen[] ambient=, pen[] specular=, pen background=, real specularfactor=, bool viewport=, triple[] position); +light light(explicit light light); +light light(pen diffuse=, pen ambient=, pen specular=, pen background=, bool viewport=, real x, real y, real z); +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; +bool needshipout(); +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=); +path box(pair a, pair b); +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=); +pen Bookman(string series=, string shape=); +void seekeof(file f); +path unitcircle; +framedTransformStack xformStack; +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(); +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=, real magnification=, transform xform()); +void deconstruct(picture pic=, real magnification=); +int sgn(real x); +pair minAfterTransform(transform t, path[] a); +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); +string Link(string label, string text, string options=); +void close(file f); +real lineskip(pen p=); +pen dashed; +pair maxAfterTransform(transform t, path[] a); +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=); +void prepend(frame dest, frame src); +real pt; +settings settings; +int MoveQuiet; +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=); +coord[] copy(coord[] a, int depth=); +coord[] copy(coord[] a, int depth=); +picture[] copy(picture[] a, int depth=); +marker[] copy(marker[] a, int depth=); +Legend[] copy(Legend[] a, int depth=); +Label[] copy(Label[] 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=); +bool3[] copy(bool3[] a, int depth=); +object[] copy(object[] 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, pen penb, pair b, bool copy=); +void axialshade(picture pic=, path[] g, bool stroke=, pen pena, pair a, pen penb, pair b, 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; +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); +bool3[] map(bool3 f(bool3), bool3[] a); +frame[] map(frame f(frame), frame[] a); +coord[] map(coord f(coord), coord[] a); +pen[][] map(pen[] f(pen[]), pen[][] a); +triple[] map(triple f(triple), triple[] a); +pen[] map(pen f(pen), pen[] a); +pair[] map(pair f(pair), pair[] a); +coord[] map(coord f(coord), coord[] a); +Label[] map(Label f(Label), Label[] a); +string[] map(string f(string), string[] a); +object[] map(object f(object), object[] a); +void()()[] map(void f()()(void()()), void()()[] a); +pair[][] map(pair[] f(pair[]), pair[][] a); +real[] map(real f(real), real[] a); +Legend[] map(Legend f(Legend), Legend[] a); +int[] map(int f(int), int[] a); +string[][] map(string[] f(string[]), string[][] a); +bool[] map(bool f(bool), bool[] a); +path[] map(path f(path), path[] a); +real[][] map(real[] f(real[]), real[][] a); +picture[] map(picture f(picture), picture[] a); +marker[] map(marker f(marker), marker[] 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); +coord[] sequence(coord f(int), int n); +coord[] sequence(coord f(int), int n); +picture[] sequence(picture f(int), int n); +marker[] sequence(marker f(int), int n); +Legend[] sequence(Legend f(int), int n); +Label[] sequence(Label 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); +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); +bool3[] sequence(bool3 f(int), int n); +object[] sequence(object 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(path3 p); +pair size(picture pic, bool user=); +void size(picture pic=, real x, real y=, bool keepAspect=); +void size(picture dest, picture src); +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=); +void beep(); +pair relpoint(path p, real l); +pair[][] transpose(pair[][] a); +pen[][] transpose(pen[][] a); +string[][] transpose(string[][] a); +real[][] transpose(real[][] a); +pen overwrite(int n); +int overwrite(pen p=); +pen linewidth(real x); +real linewidth(pen p=); +transformation transformation(real[][] modelview); +transformation transformation(real[][] modelview, real[][] projection); +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=); +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 report(string text); +void report(int i); +void report(transform t); +void add(frame dest, frame src); +void add(picture pic=, Label L); +void add(picture pic=, void d(frame f, transform t), bool exact=); +void add(frame dest, frame src, filltype filltype, bool above=); +void add(frame dest, frame src, bool group, filltype filltype=, bool above=); +void add(picture pic=, void d(picture, real[][]), bool exact=); +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 src, pair position, bool group=, filltype filltype=, bool above=); +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, real[][] t, picture pic, projection P), bool exact=); +void add(frame f, transform t=, Label L); +void add(picture pic=, void d(picture, transform), bool exact=); +void add(picture dest, picture src, bool group=, filltype filltype=, bool above=); +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=); +plain plain; +void purge(int divisor=); +int Round(real x); +real sqrt(real x); +real[] sqrt(real[] a); +pair sqrt(explicit pair z); +real[] times(path p, real x); +real[] times(path p, explicit pair z); +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(frame f); +object object(Label L); +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=); +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=); +bool3[] array(int n, bool3 value, int depth=); +object[] array(int n, object 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=); +coord[] array(int n, coord value, int depth=); +coord[] array(int n, coord value, int depth=); +picture[] array(int n, picture value, int depth=); +marker[] array(int n, marker value, int depth=); +Legend[] array(int n, Legend value, int depth=); +Label[] array(int n, Label 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=); +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)); +bool BeginArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=, real size=, real angle=, filltype filltype=, position position=); +marginT BeginPenMargin(path, pen); +int round(real x); +marginT BeginDotMargin(path, pen); +bool BeginArcArrow(picture, path, pen, marginT(path, pen)); +bool BeginArcArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=, real size=, real angle=, filltype filltype=, position position=); +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); +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 prcshininess, triple normal, pen[] colors, bool lighton, int interaction, bool prc=); +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 prcshininess, pen[] colors, bool lighton); +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=), 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))); +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(picture pic=, guide[] g, pen p=, Label legend=, marker marker=); +void draw(pair origin, picture pic=, guide[] g, pen p=, Label legend=, marker marker=); +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(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(frame f, guide[] g, pen p=); +void draw(frame f, path g, pen p=); +int mantissaBits; +real identity(real x); +real[] identity(real[] a); +transform identity(); +real[][] identity(int n); +real[][] identity4; +marker[] MarkFill; +pen pattern(string s); +string pattern(pen p); +transform invert; +transform inverse(transform t); +real[][] inverse(real[][] a); +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=); +void drawPRCdisk(frame f, real[][] t, pen[] p, real opacity, real shininess); +void drawPRCtube(frame f, path3 center, path3 g, pen[] p, real opacity, real shininess); +int CLZ(int a); +void drawPRCsphere(frame f, real[][] t, bool half=, pen[] p, real opacity, real shininess, int type); +arrowhead DefaultHead; +void drawPRCcylinder(frame f, real[][] t, pen[] p, real opacity, real shininess); +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(pairOrTriple a); +void write(string s=, cputime c, string format=, 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=, explicit path[] x, void suffix(file)=); +void write(file file=, align align, 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(string s=, bool3 b, void suffix(file)=); +void write(file file, string s=, bool3 b, void suffix(file)=); +void write(string s=, explicit guide[] x, 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); +pen dotted; +string blend(pen p); +arrowhead HookHead; +arrowhead HookHead(real dir=, real barb=); +Legend[] concat(... Legend[][]); +real[] concat(... real[][]); +object[] concat(... object[][]); +pair[] concat(... pair[][]); +coord[] concat(... coord[][]); +Label[] concat(... Label[][]); +pen[] concat(... pen[][]); +path[] concat(... path[][]); +coord[] concat(... coord[][]); +int[] concat(... int[][]); +void()()[] concat(... void()()[][]); +bool3[] concat(... bool3[][]); +string[] concat(... string[][]); +picture[] concat(... picture[][]); +marker[] concat(... marker[][]); +triple[] concat(... triple[][]); +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(hsv a, hsv b); +bool alias(coord[] a, coord[] b); +bool alias(projection a, projection b); +bool alias(picture a, picture b); +bool alias(marker a, marker b); +bool alias(pair[] a, pair[] b); +bool alias(scaling a, scaling b); +bool alias(bounds a, bounds b); +bool alias(scaleT a, scaleT b); +bool alias(position a, position b); +bool alias(cputime a, cputime b); +bool alias(int[] a, int[] b); +bool alias(string[][] a, string[][] b); +bool alias(filltype a, filltype b); +bool alias(coord[] a, coord[] b); +bool alias(coords2 a, coords2 b); +bool alias(Legend a, Legend b); +bool alias(align a, align b); +bool alias(framedTransformStack a, framedTransformStack b); +bool alias(Label[] a, Label[] b); +bool alias(real[][] a, real[][] b); +bool alias(bool3 a, bool3 b); +bool alias(bool3[] a, bool3[] b); +bool alias(light a, light b); +bool alias(indexedTransform a, indexedTransform b); +bool alias(arrowhead a, arrowhead b); +bool alias(string[] a, string[] b); +bool alias(frame[] a, frame[] b); +bool alias(coords2 a, coords2 b); +bool alias(coord a, coord b); +bool alias(autoscaleT a, autoscaleT b); +bool alias(Label a, Label b); +bool alias(Legend[] a, Legend[] b); +bool alias(bool[] a, bool[] b); +bool alias(void()()[] a, void()()[] b); +bool alias(pen[][] a, pen[][] b); +bool alias(marginT a, marginT b); +bool alias(freezableBounds a, freezableBounds b); +bool alias(transformation a, transformation b); +bool alias(pairOrTriple a, pairOrTriple b); +bool alias(path[] a, path[] b); +bool alias(triple[] a, triple[] b); +bool alias(coord a, coord b); +bool alias(coords3 a, coords3 b); +bool alias(side a, side b); +bool alias(picture[] a, picture[] b); +bool alias(marker[] a, marker[] b); +bool alias(processtime a, processtime b); +bool alias(real[] a, real[] b); +bool alias(pen[] a, pen[] b); +bool alias(slice a, slice b); +bool alias(scaling a, scaling b); +bool alias(ScaleT a, ScaleT b); +bool alias(object a, object b); +bool alias(object[] a, object[] b); +real pi; +int getint(string name=, int default=, string prompt=, bool store=); +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 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); +path[] sort(path[] a, bool less(path, path)); +Legend[] sort(Legend[] a, bool less(Legend, Legend)); +pair[] sort(pair[] a, bool less(pair, pair)); +void()()[] sort(void()()[] a, bool less(void()(), void()())); +real[] sort(real[] a, bool less(real, real)); +bool[] sort(bool[] a, bool less(bool, bool)); +object[] sort(object[] a, bool less(object, object)); +coord[] sort(coord[] a, bool less(coord, coord)); +Label[] sort(Label[] a, bool less(Label, Label)); +pen[] sort(pen[] a, bool less(pen, pen)); +pen[][] sort(pen[][] a, bool less(pen[], pen[])); +guide[] sort(guide[] a, bool less(guide, guide)); +real[][] sort(real[][] a, bool less(real[], real[])); +triple[] sort(triple[] a, bool less(triple, triple)); +coord[] sort(coord[] a, bool less(coord, coord)); +string[] sort(string[] a, bool less(string, string)); +int[] sort(int[] a, bool less(int, int)); +string[][] sort(string[][] a, bool less(string[], string[])); +bool3[] sort(bool3[] a, bool less(bool3, bool3)); +pair[][] sort(pair[][] a, bool less(pair[], pair[])); +picture[] sort(picture[] a, bool less(picture, picture)); +marker[] sort(marker[] a, bool less(marker, marker)); +frame[] sort(frame[] a, bool less(frame, frame)); +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)); +bool Arrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=, real size=, real angle=, filltype filltype=, position position=); +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 unitsize(picture pic=, real x, real y=, real z=); +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=); +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); +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=); +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=); +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); +pen longdashdotted; +void usepackage(string s, string options=); +real side(pair a, pair b, pair c); +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); +marginT TrueMargin(path, pen)(real begin, real end); +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); +void initXasyMode(); +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; +void warning(string s, string t, bool position=); +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=); +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; +bool diagnostics; +string minipage(string s, real width=); +real legendmaxrelativewidth; +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); +pen operator +(pen p, real w); +marginT operator +(path, pen)(marginT ma(path, pen), marginT mb(path, pen)); +pen[] operator +(pen a, pen[] b); +pen operator +(real w, pen p); +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); +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); +object operator *(transform t, explicit object F); +Label operator *(transform t, Label L); +picture operator *(real[][] t, picture orig); +path[] operator *(transform t, explicit path[] p); +bounds operator *(transform t, bounds b); +pair[] operator *(transform t, pair[] z); +picture operator *(transform t, picture orig); +side operator *(real x, side s); +Label operator *(real[][] t, Label L); +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(); +hsv operator init(); +projection operator init(); +picture operator init(); +marker operator init(); +marginT operator init(); +transformation operator init(); +pairOrTriple operator init(); +filltype operator init(); +coords2 operator init(); +Legend operator init(); +align operator init(); +framedTransformStack operator init(); +slice operator init(); +scaling operator init(); +ScaleT operator init(); +object operator init(); +coords2 operator init(); +coord operator init(); +autoscaleT operator init(); +Label operator init(); +scaling operator init(); +bounds operator init(); +scaleT operator init(); +position operator init(); +cputime operator init(); +coord operator init(); +coords3 operator init(); +side operator init(); +processtime operator init(); +bool3 operator init(); +light operator init(); +indexedTransform operator init(); +arrowhead 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); +object operator cast(Label L); +Label operator cast(object F); +guide[] operator cast(path[] g); +position operator cast(pair x); +align operator cast(side side); +pair operator cast(position P); +bool3[] operator cast(bool[] b); +object operator cast(frame f); +guide[] operator cast(pair[] z); +path[] operator cast(guide[] g); +bool operator cast(bool3 b); +path[] operator cast(guide g); +pen operator cast(hsv hsv); +path[] operator cast(pair[] z); +path[] operator cast(path p); +pair operator cast(pairOrTriple a); +triple operator cast(pairOrTriple a); +bool[] operator cast(bool3[] b); +position operator cast(int x); +hsv operator cast(pen p); +object operator cast(string s); +align operator cast(pair dir); +bool3 operator cast(bool b); +position operator cast(real x); +Label operator cast(string s); +align operator cast(triple dir); +frame operator cast(object F); +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(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); +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 ==(bool3 a, bool3 b); +bool operator ==(light a, light b); +bool operator ==(indexedTransform a, indexedTransform b); +bool operator ==(arrowhead a, arrowhead b); +bool operator ==(coords2 a, coords2 b); +bool operator ==(coord a, coord b); +bool operator ==(autoscaleT a, autoscaleT b); +bool operator ==(Label a, Label b); +bool operator ==(marginT a, marginT b); +bool operator ==(freezableBounds a, freezableBounds b); +bool operator ==(transformation a, transformation b); +bool operator ==(pairOrTriple a, pairOrTriple b); +bool operator ==(coord a, coord b); +bool operator ==(coords3 a, coords3 b); +bool operator ==(side a, side b); +bool operator ==(processtime a, processtime b); +bool operator ==(slice a, slice b); +bool operator ==(scaling a, scaling b); +bool operator ==(ScaleT a, ScaleT b); +bool operator ==(object a, object b); +bool operator ==(bool3 a, bool b); +bool operator ==(hsv a, hsv b); +bool operator ==(projection a, projection b); +bool operator ==(picture a, picture b); +bool operator ==(marker a, marker b); +bool operator ==(scaling a, scaling b); +bool operator ==(bounds a, bounds b); +bool operator ==(scaleT a, scaleT b); +bool operator ==(position a, position b); +bool operator ==(cputime a, cputime b); +bool operator ==(bool a, bool3 b); +bool operator ==(filltype a, filltype b); +bool operator ==(coords2 a, coords2 b); +bool operator ==(Legend a, Legend b); +bool operator ==(align a, align b); +bool operator ==(framedTransformStack a, framedTransformStack 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 !=(bool3 a, bool3 b); +bool operator !=(light a, light b); +bool operator !=(indexedTransform a, indexedTransform b); +bool operator !=(arrowhead a, arrowhead b); +bool operator !=(coords2 a, coords2 b); +bool operator !=(coord a, coord b); +bool operator !=(autoscaleT a, autoscaleT b); +bool operator !=(Label a, Label b); +bool operator !=(marginT a, marginT b); +bool operator !=(freezableBounds a, freezableBounds b); +bool operator !=(transformation a, transformation b); +bool operator !=(pairOrTriple a, pairOrTriple b); +bool operator !=(coord a, coord b); +bool operator !=(coords3 a, coords3 b); +bool operator !=(side a, side b); +bool operator !=(processtime a, processtime b); +bool operator !=(slice a, slice b); +bool operator !=(scaling a, scaling b); +bool operator !=(ScaleT a, ScaleT b); +bool operator !=(object a, object b); +bool operator !=(bool3 a, bool b); +bool operator !=(hsv a, hsv b); +bool operator !=(projection a, projection b); +bool operator !=(picture a, picture b); +bool operator !=(marker a, marker b); +bool operator !=(scaling a, scaling b); +bool operator !=(bounds a, bounds b); +bool operator !=(scaleT a, scaleT b); +bool operator !=(position a, position b); +bool operator !=(cputime a, cputime b); +bool operator !=(bool a, bool3 b); +bool operator !=(filltype a, filltype b); +bool operator !=(coords2 a, coords2 b); +bool operator !=(Legend a, Legend b); +bool operator !=(align a, align b); +bool operator !=(framedTransformStack a, framedTransformStack 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); +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); +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 >=(coord a, coord b); +bool operator >=(coord a, coord b); +filltype UnFill(real xmargin=, real ymargin=); +filltype UnFill; +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); +real degrees(pair z, bool warn=); +real degrees(real radians); +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=); +guide operator ..(... guide[]); +guide operator ..(... guide[])(tensionSpecifier t); +void none(file file); +int factorial(int n); +real log(real x); +real[] log(real[] a); +pair log(explicit pair z); +guide operator --(... guide[]); +path polygon(int n); +guide operator ---(... guide[]); +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); +pen NewCenturySchoolBook(string series=, string shape=); +void()()[] saveFunctions; +bool operator |(bool a, bool b); +bool[] operator |(bool a, bool[] b); +bool[] operator |(bool[] a, bool b); +bool[] operator |(bool[] a, bool[] b); +guide operator controls(pair zout, pair zin); +guide operator controls(pair z); +string texify(string s); +tensionSpecifier operator tension(real tout, real tin, bool atleast); +tensionSpecifier operator tension(real t, bool atLeast); +bool empty(frame f); +curlSpecifier operator curl(real gamma, int p); +void end(picture pic=); +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); +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=); +bool interactive(); +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(); +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(); +void startScript(); +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; +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=, 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=); +void dot(picture pic=, Label L, pen p=, filltype filltype=); +marker dot; +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 dot(picture pic=, Label L, pair z, align align=, string format=, 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(path3 p); +indexedTransform indexedTransform(int index, transform t, bool active=); +bool finite(real x); +bool finite(pair z); +bool finite(triple v); +void updatefunction(); +void _draw(frame f, path g, pen p); +void _draw(frame f, path3 g, triple center=, pen p, 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; +path[] margin(path[] g, real xmargin, real ymargin); +pair relative(picture pic=, pair z); +real expansionfactor; +real erfc(real x); +int windingnumber(path[] p, pair z); +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(real x); +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); +void deactivatequote(picture pic=); +string format(string format, int x, string locale=); +string format(string format, string separator, real x, string locale=); +string format(string format, real x, string locale=); +string format(real x, string locale=); +real expm1(real x); +real[] expm1(real[] a); +void activatequote(picture pic=); +int undefined; +frame[] fit2(picture[] pictures, picture all); +string ask(string prompt); +pen linecap(int n); +int linecap(pen p=); +string outname(); +void newpage(frame f); +void newpage(picture pic=); +pen fontcommand(string s); +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); +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); +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; +path nib(pen p); +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=); +bool shipped; +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; +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=); +void draw(picture pic=, binarytree tree, real minDist=, real nodeMargin=, pen p=); +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=); +void searchindex(boxcontour bc, bool forward, void f(int i, int j)); +segment case1(pair p0, pair p1, pair p2, real v0, real v1, real v2); +void draw(picture pic=, Label[] L=, guide[][] g, pen[] p); +void draw(picture pic=, Label[] L=, guide[][] g, pen p=); +void draw(picture pic=, Label L, guide[] g, pen p=); +int interior; +pen[][] interior(picture pic=, guide[][] g, pen[] palette); +pen[] extend(pen[] palette, pen below, pen above); +bool same(gridpoint gp1, gridpoint gp2); +guide connect(Segment S, pair[][] z, guide join(... guide[])); +guide[] connect(Segment[] S, pair[][] z, guide join(... guide[])); +guide[][] connect(Segment[][] S, pair[][] z, guide join(... guide[])); +guide[][] connect(pair[][][] points, real[] c, guide join(... guide[])); +bool connected(boxcontour bc1, boxcontour bc2); +int exterior; +int connectedindex(boxcontour bc, boxcontour[] bca, bool activeonly=); +int connectedindex(boxcontour[] bca, boxcontour bc, bool activeonly=); +segment case2(pair p0, pair p1, pair p2, real v0, real v1, real v2); +void collect(pair[][][] points, real[] c); +int hyperbola; +int edge; +int line; +segment case3(pair p0, pair p1, pair p2, real v0, real v1, real v2); +segment checktriangle(pair p0, pair p1, pair p2, real v0, real v1, real v2); +gridpoint operator init(); +boxcontour operator init(); +boxdata operator init(); +segment operator init(); +Segment operator init(); +segment operator init(); +void fill(picture pic=, guide[][] g, pen[][] palette); +guide[][] contour(pair[][] z, real[][] f, real[] c, guide join(... guide[])=, int subsample=); +guide[][] contour(real[][] f, pair a, pair b, real[] c, guide join(... guide[])=, int subsample=); +guide[][] contour(real f(real, real), pair a, pair b, real[] c, int nx=, int ny=, guide join(... guide[])=, int subsample=); +guide[][] contour(real f(pair), pair a, pair b, real[] c, int nx=, int ny=, guide join(... guide[])=, int subsample=); +guide[][] contour(pair[] z, real[] f, real[] c, guide join(... guide[])=); +segment[][] contouredges(real[][] f, real[] c, int subsample=); +void setcontour(real f00, real f10, real f01, real f11, real epsf, boxdata bd, int i, int j, int index); +Segment[] Segment(segment[] s); +Segment[][] Segment(segment[][] s); +real eps; +segment case4(pair p0, pair p1, pair p2, real v0, real v1, real v2); +bool isCCW(pair p0, pair p1, pair p2); +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 options=); +string embed(string name, string options=, real width=, real height=); +string hyperlink(string url, string text); +string link(string url, string text, string options=); +string embed(string name, 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 drawVertexTriangle(picture pic=, pair xy, real r=, pen fgpen=); +void drawVertexTriangleO(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=); +bool XYAlign; +void do_overpaint(picture pic, path p, pen bgpen, real halfwidth, real vertexangle); +void texshipout(string stem, picture pic=, bool xalign=); +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 ghostpen; +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=); +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; +pen doublelinepen; +real doublelinespacing; +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 defaultexcursion; +real minblockheight; +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); +line altitude(vertex V); +line altitude(side side); +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); +bool finite(explicit point p); +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[] t, 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; +point[] standardizecoordsys(coordsys R=, bool warn= ... point[] M); +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=); +real perpfactor; +int conicnodesfactor; +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); +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(bqe bqe1, bqe bqe2); +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(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 intouch(side side); +triangle intouch(triangle t); +point orthocentercenter(point A, point B, point C); +point orthocentercenter(triangle t); +real rf(real x, real y, real z); +bool concurrent(... line[] l); +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); +bool between(point M, point O, point N); +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); +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); +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 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); +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); +circle operator cast(ellipse el); +ellipse operator cast(conic co); +parabola operator cast(conic co); +conic operator cast(parabola p); +hyperbola operator cast(conic co); +conic operator cast(hyperbola h); +conic operator cast(ellipse el); +conic operator cast(circle c); +circle operator cast(conic 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); +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); +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); +segment segment(point A, point B); +segment segment(line l); +segment segment(explicit side side); +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); +triangle cevian(triangle t, point P); +point cevian(side side, point P); +line cevian(vertex V, point 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=); +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=); +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); +real[] bangles(picture pic=, parabola p); +real[][] bangles(picture pic=, hyperbola h); +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=); +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 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(real k, point A, point M); +circle inverse(real k, point A, line l); +circle inverse(real k, point A, circle c); +arc inverse(real k, point A, segment s); +inversion inversion(real k, point C); +inversion inversion(point C, real k); +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); +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[])=); +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=); +tickvalues OmitTickIntervals(tickvalues)(real[] a, real[] b); +tickvalues OmitTickInterval(tickvalues)(real a, real b); +tickvalues OmitTick(tickvalues)(... real[] x); +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); +real maxlength(pair a, pair b, int nx, int ny); +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=, real maxlength=, 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; +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=); +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=); +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=); +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=); +picture secondaryX(picture primary=, void f(picture)); +picture secondaryY(picture primary=, void f(picture)); +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); +real linear(real)(real S(real x)=, real Min, real Max); +pair polar(real r, real theta); +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(); +path[] segment(pair[] z, bool[] cond, guide join(... guide[])=); +int Both; +void axes(picture pic=, Label xlabel=, Label ylabel=, pair min=, pair max=, pen p=, bool arrow(picture, path, pen, marginT(path, pen))=, marginT margin(path, pen)=, bool above=); +string signedtrailingzero; +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); +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)[])=); +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=); +bool uperiodic(triple[][] 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 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(triple[][] f, bool[][] cond=); +surface surface(real[][] f, real[] x, real[] y, real[] xsplinetype(real[], real[])=, real[] ysplinetype(real[], real[])=, bool[][] cond=); +surface surface(real[][] f, pair a, pair b, real[] xsplinetype(real[], real[]), real[] ysplinetype(real[], real[])=, bool[][] cond=); +surface surface(real[][] f, pair a, pair b, bool[][] cond=); +surface surface(triple f(pair z), pair a, pair b, int nu=, int nv=, bool cond(pair z)=); +surface surface(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(real f(pair z), pair a, pair b, int nx=, int ny=, bool cond(pair z)=); +surface surface(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); +real ScaleZ(picture pic=, real z); +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=, 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 zero3(real); +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=); +path3[] segment(triple[] v, bool[] cond, void join(flatguide3)(... void(flatguide3)[])=); +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; +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 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=); +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); +triple ZX(picture pic); +grid3(picture pic)[] XZXgrid(position pos=); +grid3(picture pic)[] XZXgrid; +grid3(picture pic)[] ZXZgrid(position pos=); +grid3(picture pic)[] ZXZgrid; +position top; +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); +grid3 XZgrid(picture pic)(position pos=); +grid3 XZgrid(picture pic); +grid3 YZgrid(picture pic)(position pos=); +grid3 YZgrid(picture pic); +triple XY(picture pic); +position middle; +grid3(picture pic)[][] XYZgrid(position pos=); +grid3(picture pic)[][] XYZgrid; +grid3(picture pic)[] ZYZgrid(position pos=); +grid3(picture pic)[] ZYZgrid; +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 slope(path g, explicit pair z, int n=); +picture grid(int Nx, int Ny, pen p=); +int[][] segment(bool[] b); +real frac(real x); +real asec(real x); +real time(path g, real x, int n=); +real time(path g, explicit pair z, int n=); +bool increasing(real[] a, bool strict=); +real[] zero(int n); +real[][] zero(int n, int m); +real acsc(real x); +real value(path g, real x, int n=); +real value(path g, explicit pair z, int n=); +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 g(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 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, 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, 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); +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=); +void gsave(picture pic=); +pair align; +pen textpen; +path roundedpath(path A, real R, real S=); +problem operator init(); +real infinity; +pen authorpen; +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 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=); +int page; +void usersetting(); +bool landscape; +real codeskip; +void newslide(bool stepping=); +void nextpage(pen p=); +pen itempen; +void filecode(bool center=, string s, pen p=, real indent=, real skip=, filltype filltype=); +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 dateskip; +pair titlealign; +pen titlepagepen; +void titlepage(string title, string author, string institution=, string date=, string url=, bool newslide=); +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; +void item(string s, pen p=, bool step=); +int[] firstnode; +bool firststep; +string asywrite(string s, string preamble=); +pair startposition; +string oldbulletcolor; +string newbulletcolor; +pen datepen; +void incrementposition(pair z); +pen institutionpen; +string cropcode(string s); +void skip(real n=); +bool stepping; +real pagemargin; +pen steppagenumberpen; +bool allowstepping; +pair currentposition; +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 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=); +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=, bool arrow(picture, path, pen, marginT(path, pen))=); +picture slopefield(real f(real), pair a, pair b, int nx=, int ny=, pen p=, bool arrow(picture, path, pen, marginT(path, pen))=); +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); +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=); +real stdev(real[] A); +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); +real kurtosis(real[] A); +real kurtosisexcess(real[] A); +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=); +pair[] endpoints(guide[] a); +Relation r3; +picture tableau(frame[] cards, bool number=); +pair min(pair[] z); +Component bp; +Braid apply(Relation r, Braid b, int step, int place); +Component phi; +real gapfactor; +Component bm; +Component wye; +Relation operator -(Relation r); +Component operator init(); +Braid operator init(); +Relation operator init(); +Syzygy operator init(); +Relation r4b; +real hwratio; +Relation r4a; +pair max(pair[] z); +pen Orchid; +pen Magenta; +pen BrickRed; +pen CadetBlue; +pen CarnationPink; +pen SpringGreen; +pen MidnightBlue; +pen OliveGreen; +pen Apricot; +pen Aquamarine; +pen Cyan; +pen Lavender; +pen Red; +pen RawSienna; +pen Mahogany; +pen Gray; +pen Plum; +pen BlueGreen; +pen Cerulean; +pen Blue; +pen BlueViolet; +pen RedOrange; +pen Goldenrod; +pen ForestGreen; +pen BurntOrange; +pen Tan; +pen YellowOrange; +pen Maroon; +pen YellowGreen; +pen Brown; +pen RubineRed; +pen TealBlue; +pen White; +pen Purple; +pen Bittersweet; +pen Orange; +pen OrangeRed; +pen Fuchsia; +pen Peach; +pen Sepia; +pen PineGreen; +pen Dandelion; +pen Black; +pen VioletRed; +pen NavyBlue; +pen Violet; +pen Rhodamine; +pen ProcessBlue; +pen LimeGreen; +pen Thistle; +pen Green; +pen GreenYellow; +pen DarkOrchid; +pen Emerald; +pen Mulberry; +pen RedViolet; +pen SkyBlue; +pen SeaGreen; +pen WildStrawberry; +pen Periwinkle; +pen Yellow; +pen JungleGreen; +pen Salmon; +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; +real[] sample(path3 g, real r, real relstep=); +path3 roundedpath(path3 A, real r); +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); +string VERSION; +pen Orchid; +pen Indigo; +pen Beige; +pen SlateBlue; +pen SlateGray; +pen Magenta; +pen SteelBlue; +pen CadetBlue; +pen DeepPink; +pen SpringGreen; +pen MidnightBlue; +pen Olive; +pen OliveDrab; +pen LemonChiffon; +pen Aquamarine; +pen Chocolate; +pen Cyan; +pen Gainsboro; +pen Lavender; +pen Aqua; +pen Ivory; +pen PapayaWhip; +pen Red; +pen Pink; +pen MintCream; +pen DarkTurquoise; +pen Gray; +pen MediumBlue; +pen MediumOrchid; +pen MediumPurple; +pen MediumSeaGreen; +pen MediumSlateBlue; +pen MediumAquamarine; +pen MediumSpringGreen; +pen MediumTurquoise; +pen MediumVioletRed; +pen Plum; +pen Blue; +pen Gold; +pen Sienna; +pen BlueViolet; +pen Goldenrod; +pen ForestGreen; +pen Chartreuse; +pen NavajoWhite; +pen Tan; +pen DarkMagenta; +pen Maroon; +pen AntiqueWhite; +pen YellowGreen; +pen PaleTurquoise; +pen IndianRed; +pen Crimson; +pen Azure; +pen LawnGreen; +pen Brown; +pen BurlyWood; +pen Moccasin; +pen DarkBlue; +pen Peru; +pen White; +pen Purple; +pen WhiteSmoke; +pen DimGray; +pen DarkOliveGreen; +pen DarkOrange; +pen Orange; +pen OrangeRed; +pen Fuchsia; +pen PeachPuff; +pen Honeydew; +pen Bisque; +pen RosyBrown; +pen Silver; +pen Black; +pen Khaki; +pen FireBrick; +pen Violet; +pen Snow; +pen SandyBrown; +pen LimeGreen; +pen Lime; +pen Thistle; +pen DeepSkyBlue; +pen OldLace; +pen Green; +pen GreenYellow; +pen DarkCyan; +pen FloralWhite; +pen DarkRed; +pen DarkOrchid; +pen Cornsilk; +pen BlanchedAlmond; +pen PowderBlue; +pen DarkGray; +pen DarkGreen; +pen DarkGoldenrod; +pen SkyBlue; +pen SeaGreen; +pen DarkViolet; +pen Teal; +pen AliceBlue; +pen HotPink; +pen Seashell; +pen DodgerBlue; +pen SaddleBrown; +pen Tomato; +pen DarkKhaki; +pen GhostWhite; +pen LightBlue; +pen LightCoral; +pen LightCyan; +pen Yellow; +pen LightGreen; +pen PaleGreen; +pen Linen; +pen LightGoldenrodYellow; +pen LightGrey; +pen LightPink; +pen PaleGoldenrod; +pen LightSalmon; +pen LightSeaGreen; +pen Navy; +pen LightSkyBlue; +pen LightSlateGray; +pen PaleVioletRed; +pen Salmon; +pen LightSteelBlue; +pen LightYellow; +pen CornflowerBlue; +pen rgbint(int r, int g, int b); +pen Coral; +pen MistyRose; +pen LavenderBlush; +pen DarkSalmon; +pen Wheat; +pen DarkSeaGreen; +pen RoyalBlue; +pen DarkSlateBlue; +pen DarkSlateGray; +pen Turquoise; -- cgit v1.2.3