This is the list of Frequently Asked Questions about Asymptote (asy).
camp refer to?Asymptote is a vector graphics language designed for technical graphics, inspired by MetaPost but with IEEE floating-point numerics, native three-dimensional graphics, Grayscale/RGB/CMYK colourspaces, and a C++-like syntax. Unlike MetaPost, it natively supports multiple-segment paths (and hence regions other than simply connected ones), tiling patterns, Gouraud shading, tensor patch shading, and PostScript images.
Binary releases are available for Linux, MacOS X, and Microsoft Windows platforms, in addition to full source code, from the website https://asymptote.sourceforge.io/. Many Linux distributions (such as RedHat and Debian) now include an Asymptote package (check your distribution’s documentation for further information about this).
If you have a question, please try to find an answer in this FAQ, in the extensive Asymptote documentation at https://asymptote.sourceforge.io/doc/, or search the forum: http://sourceforge.net/forum/forum.php?forum_id=409349.
Well, it isn’t the perfect graphics package, but we do think it is getting there asymptotically...
camp refer to? ¶That was our original tentative name for this project, which stood for "C’s Answer to MetaPost" (the language that inspired Asymptote). However, we eventually decided that the name Asymptote better emphasizes the mathematical and graphical nature of this language.
Bad CPU type in executable on installing Asymptote from the MAC OS binary?Error: pdfetex (file pdftex.cfg): cannot open config file...texinfo.tex appears to be broken?! Undefined control sequence. l.6 @copying?tkinter package to install an Asymptote rpm binary?%USERPROFILE%\.asy\config.asy mean?settings.dir="C:\asymptote\";?It is easy to compile Asymptote directly from the source code at http://sourceforge.net/project/showfiles.php?group_id=120000 We recommend first upgrading to the latest GNU readline library, unless you don’t care about interactive readline support (in which case configure will automatically detect and disable obsolete versions of the readline library). Marius Schamschula also maintains a binary package for various MacOS X platforms http://www.hmug.org/pub/MacOS_X/X/Applications/Publishing/asymptote.
Bad CPU type in executable on installing Asymptote from the MAC OS binary? ¶This means either that you have a binary distribution for another MAC architecture, or (according to Marius Schamschula) that you may have a missing library. The simplest solution is to compile Asymptote directly from the official source: http://sourceforge.net/project/showfiles.php?group_id=120000.
Error: pdfetex (file pdftex.cfg): cannot open config file...texinfo.tex appears to be broken? ¶Simply put https://asymptote.sourceforge.io/asymptote.pdf in the directory doc and repeat the command make all. Or, if you don’t want to build a local copy of the documentation, simply proceed with make install-asy.
! Undefined control sequence. l.6 @copying? ¶Either upgrade your texinfo package or follow one of the easy work arounds in Question 2.3.
Yes, see the example latexusage.tex. Dario Teixeira has also written a detailed guide on the topic. You can download it from http://dario.dse.nl/projects/asylatex/.
Philippe Ivaldi has contributed an Asymptote mode for Emacs users https://asymptote.sourceforge.io/doc/Editing-modes.html, which includes a lasy-mode that allows one to compile and view the output of one \begin{asy}...\end{asy} section at a time.
Yes, as of version 1.14, Asymptote supports latex and pdflatex (both in EPS/PDF and inline mode), as illustrated by the example latexusage.tex:
pdflatex latexusage asy latexusage pdflatex latexusage
tkinter package to install an Asymptote rpm binary? ¶No, you don’t need tkinter unless you want to try out the GUI xasy. Try
rpm -Uvh --nodeps asymptote-x.xx-1.i386.rpm
where x.xx represents the version number.
%USERPROFILE%\.asy\config.asy mean? ¶That is the way that Microsoft Windows refers to the user profile directory. There’s nothing really to understand here, just put your configuration commands in the file config.asy in a new folder %USERPROFILE%\.asy.
settings.dir="C:\asymptote\";? ¶The backslash is an escape character here, so \" is interpreted as a verbatim quotation mark, leaving the string without a terminating quotation mark. Fortunately, this is the only escaped character in double-quoted strings. A final backslash isn’t needed here anyway, but should you really want one somewhere, you can say: settings.dir="C:\asymptote"+'\\';.
While it is easier to set the corresponding Asymptote configuration variable in your config.asy file, here is the procedure for changing Microsoft Windows environment variables:
Click on the [Start] button
* RIGHT-click on ’My Computer’
* Choose ’Properties’ from the popup menu
* Click the ’Advanced’ tab
* Click the ’Environment Variables’ button.
This means that ImageMagick wasn’t properly installed and you are using the MSDOS convert program rather than the ImageMagick one. Or you may have installed ImageMagick but ran Asymptote from an existing MSDOS window. In that case, simply open a new window and try again. If that doesn’t work, check that
convert --version
returns something like
Version: ImageMagick 6.2.8 06/27/06 Q16 http://www.imagemagick.org
Likely, this means that latex and dvips are not in your default path. Try adding the appropriate paths in your config.asy file, for example:
import settings; latex="C:\Program Files\MiKTeX 2.7\miktex\bin\latex.exe"; dvips="C:\Program Files\MiKTeX 2.7\miktex\bin\dvips.exe";
What is happening here is that
draw((0,0)..tension 2..(0,50)..(100,100));
is read as
draw((0,0)..tension 2. .(0,50)..(100,100));
So the first . after the two is treated as a decimal point. Just put a space after the integer tension value:
draw((0,0)..tension 2 ..(0,50)..(100,100));
From the documentation:
"The dot command defined in the module plain draws a dot having a diameter equal to an explicit pen linewidth or the default linewidth magnified by dotfactor (6 by default)."
Thus, when you use the default pen, the dot will have size 6*linewidth, but when you give a pen with an explicit width specified, you will have a dot of size linewidth. If you want the first case to behave like the second, you may set dotfactor=1.
mathptmx?texpreamble("\usepackage[pdftex]{hyperref}") from changing the page size?In (La)TeX, Greek letters can be obtained in math mode by prepending a backslash to the letter name. So for a omega symbol, use "$\omega$". Everything between the dollar signs is considered to be a math formula. Uppercase Greek letters can be used by capitalizing the first letter of the name:
label("$\omega$",(0,0));
label("$\Omega$",(20,0));
Yes:
usepackage("amsmath");
label("$\begin{matrix} 1 & 2 \\\ 1 & 1 \end{matrix}$",(0,0));
mathptmx? ¶Put
usepackage("mathptmx");
at the beginning of your file. Note: to enable the Adobe Times Roman font for text, you will also need to say:
defaultpen(TimesRoman());
See https://asymptote.sourceforge.io/doc/Pens.html.
usepackage("fourier");
defaultpen(font("T1","fut\textfamilyextension","m","n"));
Just set your locale appropriately:
locale("it_IT");
usepackage("icomma");
label(format(0.5));
frame f; label(f,"This is some text",white,Fill(blue)); add(rotate(65)*f);
You need to first project the triple to a pair like this:
import three; size(100,100); draw(rotate(90,project(Z))*"A",O--X);
Fixed-size objects should be drawn on a separate picture and then added to currentpicture. Here is one way (see also https://asymptote.sourceforge.io/gallery/subpictures.asy and https://asymptote.sourceforge.io/gallery/mosquito.asy):
real u=2cm;
picture square;
draw(square,scale(u)*shift(-0.5,-0.5)*unitsquare);
picture circle;
draw(circle,scale(0.5u)*unitcircle);
void add(picture pic=currentpicture, Label L, picture object, pair z) {
add(pic,object,z);
label(pic,L,z);
}
add("square",square,(0,0));
add("circle",circle,(5cm,0));
The scaling factor can be greater than 1. But keep in mind that the rgb color components saturate at 1.
Try
write(cyan); write(0.8*cyan); write(1.5*cyan);
and you will quickly see what is going on.
To get a lighter cyan you can say white+cyan, which yields rgb(0.5,1,1). If you want something even lighter specify the rgb colors directly, for example, rgb(0.9,1,1).
Alternatively, work in cmyk colour space, which is nicer in that it handles saturation separately from hue:
0.1*Cyan is light and 0.9*Cyan is dark. You can also say 0.1*cmyk(red).
LaTeX is treating the comma as punctuation and not as a decimal separator. The solution is to load the icomma package near the beginning of your file:
usepackage("icomma");
texpreamble("\usepackage[pdftex]{hyperref}") from changing the page size? ¶texpreamble("\usepackage[pdftex,setpagesize=false]{hyperref}");
Assuming that at least one of the arrowheads is to be filled, you can do this:
size(200); path g = (0,0)..(1,3)..(3,0); draw(g,Arrow(Relative(0.9))); add(arrow(g,invisible,FillDraw(black),Relative(0.5))); add(arrow(reverse(g),invisible,FillDraw(white,black),Relative(0.9)));
If both of the arrowheads are to be drawn with filltype NoFill, one will need to create a specialized version of the arrow routine in plain_arrows.asy:
void arrow(frame f, arrowhead arrowhead=DefaultHead,
path g, pen p=currentpen, real size=0,
real angle=arrowangle, filltype filltype=arrowhead.defaultfilltype,
position position=EndPoint, bool forwards=true,
margin margin=NoMargin, bool center=false);
Simply reverse the direction of the path.
path g=((0,0)--(5cm,0)); draw(reverse(g),Arrow(Relative(0.55)));
To override the arrowsize you can give every Arrow drawing attribute a real size argument. If you want to do this globally, you can override the pen-dependent arrowsize function like this:
DefaultHead.size=new real(pen p=currentpen) {return 2mm;};
Yes, you can build custom arrowheads like this (see the predefined arrowhead styles in plain_arrows.asy for further examples):
arrowhead DotHead;
DotHead.head=new path(path g, position position=EndPoint, pen p=currentpen,
real size=0, real angle=arrowangle) {
if(size == 0) size=DotHead.size(p);
bool relative=position.relative;
real position=position.position.x;
if(relative) position=reltime(g,position);
path r=subpath(g,position,0);
pair x=point(r,0);
real t=arctime(r,size);
pair y=point(r,t);
return circle(0.5(x+y),0.5size);
};
size(100);
draw((0,0)..(1,1)..(2,0),Arrow(DotHead));
dot((2,0),red);
If you submit your alternate arrowheads to the Forum or the Patch Tracking System, we’ll consider including them in a future release.
import graph;
size(250,200,IgnoreAspect);
draw(graph(exp,-1,1),red);
xaxis("$x$",RightTicks(Label(align=left)));
yaxis("$y$",RightTicks);
import graph;
size(250,200,IgnoreAspect);
draw(graph(exp,-1,1),red);
xaxis(Label("$x$",0.75),LeftTicks);
yaxis("$y$",RightTicks);
import graph;
size(250,200,IgnoreAspect);
draw(graph(exp,-1,1),red);
xaxis(shift(0,-10)*"$x$",LeftTicks);
yaxis("$y$",RightTicks);
Yes:
import graph;
size(300,200,IgnoreAspect);
xlimits(-50,50);
ylimits(0,100);
xaxis(Label("$x$",MidPoint,red),Bottom,blue,LeftTicks(green));
yaxis("$y$",Left,RightTicks);
import graph;
size(300,200,IgnoreAspect);
xlimits(-50,50);
ylimits(0,100);
xaxis("x",Bottom,Courier("m","n"),LeftTicks);
yaxis("$y$",Left,RightTicks);
Tick labels are by default typeset in (TeX) math mode, so to use other fonts you need to override the default tick format:
import graph;
size(300,200,IgnoreAspect);
xlimits(-50,50);
ylimits(0,100);
xaxis("$x$",Bottom,LeftTicks("%.4g",Courier("m","n")+fontsize(12)));
yaxis("$y$",Left,RightTicks);
Either:
(i) give LeftTicks/RightTicks/Ticks the arguments beginlabel=false and/or endlabel=false;
(ii) explicitly remove specific ticks and their labels (drawing them manually; see http://www.github.com/vectorgraphics/asymptote/base/graph.asy for the definition of NoZero):
import graph;
size(10cm);
real f(real x) {return x^2;}
draw(graph(f,-2,2));
xaxis(Ticks(NoZero));
yaxis(Ticks(NoZero));
label("$0$",(0,0),SW);
(iii) explicitly remove specific tick labels and draw them manually (see http://www.github.com/vectorgraphics/asymptote/base/graph.asy for the definition of NoZeroFormat):
import graph;
size(10cm);
real f(real x) {return x^2;}
draw(graph(f,-2,2));
xaxis(Ticks(NoZeroFormat));
yaxis(Ticks(NoZeroFormat));
label("$0$",(0,0),SW);
(iv) use the xasy GUI to move overlapping labels;
(v) change the Label argument of LeftTicks, RightTicks, or Ticks to:
Label(currentpen+overwrite(Move))
Solution (v) will move labels that might otherwise overwrite a previous label. Other possible overwrite arguments are Allow (allows overlapping labels; the default), Suppress (an overlapping label will not be written at all), SuppressQuiet, and MoveQuiet. The last two achieve the same result as the non-quiet types, but will not notify you which labels are overlapping. See: https://asymptote.sourceforge.io/doc/Pens.html.
In the case of a user-specified tick array, you can change which labels get suppressed/moved by changing the order of array entries.
Either:
i) Specify an explicit unitsize, which overrides any call to size:
unitsize(x=1cm,y=2cm);
ii) Explicitly tell Asymptote to map the plot region to a specific size:
import graph;
real[] x={0,1,2,3};
real[] y=x^2;
draw(graph(x,y),red);
xaxis("$x$",BottomTop,LeftTicks);
yaxis("$y$",LeftRight,RightTicks);
size(5cm,5cm,point(SW),point(NE));
label("$f_\mathrm{T}$",point(N),2N);
iii) Specify the points in user coordinates that should correspond to a given picture size:
import graph;
size(250,200,IgnoreAspect);
draw(graph(exp,-1,1),red);
xaxis("$x$",BottomTop,LeftTicks);
yaxis("$y$",LeftRight,RightTicks);
fixedscaling((-1.5,-0.5),(1.5,3.5));
In this example, the user coordinate (-1.5,-0.5) will end up being the lower left corner of the figure and (1.5,3.5) will be the upper right corner. You can use this option to ensure multiple figures have the same scaling and same resulting figure size (just ensure the two coordinates given to fixedscaling() leaves room for any labels).
See also https://asymptote.sourceforge.io/doc/Frames-and-pictures.html.
Call limits with the Crop option before drawing the graph:
import graph;
size(250,200,IgnoreAspect);
draw(graph(exp,-1,1),red);
limits((0,0),(1,2),Crop);
xaxis("$x$",BottomTop,LeftTicks);
yaxis("$y$",LeftRight,RightTicks);
See also https://asymptote.sourceforge.io/doc/graph.html.
Yes, you may generate your own pen[] array. For example:
int NColors=32768;
pen[] MyPalette=new pen[NColors];
real step=1/(NColors-1.0);
// Start at black: rgb(0,0,0)
// End at yellow: rgb(1,1,0)
for(int i=0; i < NColors; ++i) {
real rgval=i*step;
MyPalette[i]=rgb(rgval,rgval,0.0);
}
The example below shows a continuous function and two methods for placing markers at integer values of x:
import graph;
size(200,200,IgnoreAspect);
real factorial(real t) {return gamma(t+1);}
scale(Linear,Log);
// Graph the factorial function.
draw(graph(factorial,0,10));
// Method 1: Draw nodes, but hide line
pair F(int t) {return (t,factorial(t));}
// Graph of factorial function from 0 to 10
pair[] z=sequence(F,11);
draw(graph(z),invisible,marker(scale(0.8mm)*unitcircle,blue,Fill));
// Method 2: Nongraphing routines require explicit scaling:
pair dotloc(int t) {return Scale(F(t));}
pair[] dotlocs=sequence(dotloc,11);
dot(dotlocs);
xaxis("$x$",BottomTop,LeftTicks);
yaxis("$y$",LeftRight,RightTicks);
Here’s an easy way to do this.
size(12cm,0);
void distance(picture pic=currentpicture, pair A, pair B, Label L="", real n=0,
pen p=currentpen)
{
real d=3mm;
path g=A--B;
transform T=shift(-n*d*unit(B-A)*I);
pic.add(new void(frame f, transform t) {
picture opic;
path G=T*t*g;
draw(opic,Label(L,Center,UnFill(1)),G,p,Arrows(NoFill),Bars,PenMargins);
add(f,opic.fit());
});
pic.addBox(min(g),max(g),T*min(p),T*max(p));
}
pair A=(0,0), B=(3,3);
dot(A);
dot(B);
distance(A,B,"$\ell$",1);
See the example https://asymptote.sourceforge.io/gallery/2D graphs/log2graph.asy.
An easy way to do this, if the axes to be aligned have the same scaling and size, is illustrated in the example https://asymptote.sourceforge.io/gallery/2D graphs/alignedaxis.asy.
Here is a more general solution to the problem of aligning two arbitrary axes. One fits the second picture to a frame based on the horizontal scaling for the first picture:
import graph;
real width=15cm;
real aspect=0.3;
picture pic1,pic2;
size(pic1,width,aspect*width,IgnoreAspect);
size(pic2,width,aspect*width,IgnoreAspect);
scale(pic1,false);
scale(pic2,false);
real xmin1=6;
real xmax1=9;
real xmin2=8;
real xmax2=16;
real a1=1;
real a2=0.001;
real f1(real x) {return a1*sin(x/2*pi);}
real f2(real x) {return a2*sin(x/4*pi);}
draw(pic1,graph(pic1,f1,xmin1,xmax1));
draw(pic2,graph(pic2,f2,xmin2,xmax2));
xaxis(pic1,Bottom,LeftTicks());
yaxis(pic1,"$f_1(x)$",Left,RightTicks);
xaxis(pic2,"$x$",Bottom,LeftTicks(Step=4));
yaxis(pic2,"$f_2(x)$",Left,RightTicks);
yequals(pic1,0,Dotted);
yequals(pic2,0,Dotted);
pair min1=point(pic1,SW);
pair max1=point(pic1,NE);
pair min2=point(pic2,SW);
pair max2=point(pic2,NE);
real scale=(max1.x-min1.x)/(max2.x-min2.x);
real shift=min1.x/scale-min2.x;
transform t1=pic1.calculateTransform();
transform t2=pic2.calculateTransform();
transform T=xscale(scale*t1.xx)*yscale(t2.yy);
add(pic1.fit());
real height=truepoint(N,user=false).y-truepoint(S,user=false).y;
add(shift(0,-height)*(shift(shift)*pic2).fit(T));
Here is a simple example (see also the example https://asymptote.sourceforge.io/gallery/2D graphs/diatom.asy or the discussion of Linear(-1) in the documentation):
import graph;
size(250,200,IgnoreAspect);
scale(Linear,Linear(-1));
draw(graph(log,0.1,10),red);
xaxis("$x$",LeftTicks);
yaxis("$y$",RightTicks);
Use functionshade with a PDF tex engine, as illustrated by the example {functionshading.asy}.
If you want to produce PostScript output, an approximate solution for now would be to superimpose a fine grid and specify colors to latticeshade that depend on position as a single pen[][] lattice. Alternatively, it may be more efficient to use tensorshade.
Yes, use the parametric form
y=t x=(t-2)^2+1
See the example https://asymptote.sourceforge.io/gallery/2D graphs/parametricgraph.asy.
The real scaling argument to Linear is used to stretch (or reverse) the axis. To see the effect of axis stretching, be sure not to specify IgnoreAspect in the picture size command.
A secondary axis has the same length as the primary axis, so stretching cannot have any effect. But one can still reverse the axis, with Linear(-1).
UnFill won’t work here because it only affects the local frame the markers are initially drawn on, before being added to currentpicture. Here is a way of achieving the desired effect (assuming a white background):
import graph;
size(10cm,0);
pair[] z={(0,0),(0.5,0.5),(1,1)};
path g=graph(z);
draw(shift(0,.5)*g,marker(scale(5)*unitcircle,FillDraw(white)));
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight,RightTicks);
The palette color space corresponds to a range of values specified by the argument range, which can be Full, Automatic or an explicit range Range(pair min, pair max). Here Full specifies a range varying from the minimum to maximum values of the function over the sampling interval, while Automatic selects "nice" limits.
Asymptote compiles Asymptote commands into its own virtual machine code. It then runs this pseudocode on a virtual machine to produce PostScript code.
Frames are canvases for drawing in PostScript coordinates. While working with frames directly is occasionally necessary for constructing deferred drawing routines, pictures are usually more convenient to work with. See Question 8.8.
A path is a cubic spline with fixed endpoint conditions.
A guide is an unresolved cubic spline (list of cubic-spline nodes and control points). A guide is like a path except that the computation of the cubic spline is deferred until drawing time (when it is resolved into a path); this allows two guides with free endpoint conditions to be joined together smoothly.
You could write yourself a routine such as:
picture[] picture(int n) {
picture[] pic;
for(int i=0; i < n; ++i) {
pic[i]=new picture;
size(pic[i],19cm,0);
}
return pic;
}
picture[] pic=picture(6);
Generic types aren’t yet implemented.
But for now you can at least say
typedef string T; include F; typedef real T; include F;
where F.asy contains some type-dependent code like
T[] operator $(T A, T B) {return new T[] {A,B};}
Asymptote does not support forward declaration of types. You can, however, nest structures, so that both types are visible for parts of the bodies of both structure definitions. For example:
struct B {
typedef void someroutine(B b);
static struct A {
someroutine routine;
void operator init(someroutine routine) {
this.routine=routine;
}
}
string test="Testing";
}
typedef B.A A;
A a=B.A(new void(B b){write(b.test);});
B b;
a.routine(b);
In the example
void f() {
for(int i=0; i < 3; ++i) {
static int n;
++n;
write(n);
}
}
f(); // Writes 1, 2, 3
the static qualifier means that n is allocated not just outside of the for loop, but also outside the function. This is clear if you call f multiple times; there is still only one instance of n.
The "level" of a variable (where it is allocated) has nothing to do with the "scope" of a variable (how long it can be referred to by name). The curly braces enclosing a block affect only a variable’s scope, not its level.
Static modifiers are meaningless at the top level; they generate a warning and are simply ignored:
for(int i=0; i < 3; ++i) {
static int n;
++n;
write(n);
}
// Writes warning about top-level static modifier and then 1, 1, 1
Since version 1.22, non-static variables allocated in a loop body are allocated anew every iteration. This is only noticable in obscure cases where a variable in a loop is accessed in the closure of a function defined in the loop:
int f();
for(int i=0; i < 10; ++i) {
int j=10*i;
if(i == 5)
f=new int() {return j;};
}
write(f()); // Writes 50
Variables in the body of a loop last as long as that iteration of the loop, unless they are kept alive by a function closure as in the example above. In a function body, variables will last at least as long as the function call, though because of closures and garbage collection, they may last longer than that. If defined at the top level of a file or at the interactive prompt, they will last at least until the end of the file or prompt’s run.
Yes, Asymptote includes a line-based debugger:
https://asymptote.sourceforge.io/doc/Debugger.html
Yes, in fact we would prefer that users submit patches for customized features (to http://sourceforge.net/tracker/?atid=685685&group_id=120000) instead of relying on us to do all of the coding. Development will proceed faster that way.
lray - horiz*v - verti*u = whatever*(LightSource - R), a system of three linear equations for three unknowns: horiz, verti, whatever?u and explicitly multiply all the coordinates by u. Is there a better way to do this in Asymptote?Asymptote includes an optional facility to do automatic scaling of pictures to achieve a given overall picture size, whereas Metapost only supports manual scaling. Asymptote defers drawing of objects drawn to pictures and distinguishes between true-size objects and objects that should scale with the picture size. The resulting linear programming problem is solved via the Simplex method.
See the https://asymptote.sourceforge.io/gallery/dimension.asy example for an example of how deferred drawing is used to accomodate both user and true-size (PostScript) coordinates.
If you really like Metapost-style manual (hard-wired) scaling either:
(i) use the default size(0,0) for the entire picture and do all of the scaling by hand, just like in MetaPost;
(ii) draw to a separate picture pic and add(pic.fit());
(iii) use frames.
The connector :: is a macro for tension atleast 1:
size(100);
pair z0=(0,0);
pair z1=(1,0.25);
pair z2=(2,0);
draw(z0{up}::z1{right}::z2{down});
Asymptote does not implicitly solve linear equations and therefore does not have the notion of a whatever unknown. Such a facility could certainly be added (perhaps using the notation ?= since = means assignment). However, the most common uses of whatever in MetaPost are covered by functions like extension in math.asy:
pair extension(pair P, pair Q, pair p, pair q);
this returns the intersection point of the extensions of the line segments PQ and pq. We find using routines like extension more explicit and less confusing to new users. But we could be persuaded to add something similar if someone can justify the need. In the meantime, one can always use the explicit built-in linear solver solve (see https://asymptote.sourceforge.io/doc/solve.html), which uses LU decomposition.
lray - horiz*v - verti*u = whatever*(LightSource - R), a system of three linear equations for three unknowns: horiz, verti, whatever? ¶Since horiz*v+verti*u spans a plane, you could use
real intersect(vector P, vector Q, vector n, vector Z);
to find the intersection time for the line lray-whatever*(LightSource - R) and then extract the three desired values from there. (You’ll still need to use the built-in explicit linear solver to solve a 2x2 system to get horiz and verti.)
u and explicitly multiply all the coordinates by u. Is there a better way to do this in Asymptote? ¶Yes, Asymptote has a better way: you definitely don’t want to manually scale all of your coordinates. To make the user coordinates represent multiples of exactly 1cm:
unitsize(1cm); draw(unitsquare);
One can also specify different x and y unit sizes:
unitsize(x=1cm,y=2cm); draw(unitsquare);
Another way is to draw your fixed size object to a frame and add it to currentpicture like this:
path p=(0,0)--(1,0); frame object; draw(object,scale(100)*p); add(object); add(object,(0,-10));
To understand the difference between frames and pictures, try this:
size(300,300); path p=(0,0)--(1,0); picture object; draw(object,scale(100)*p); add(object); add(object,(0,-10)); // Adds truesize object to currentpicture
If you are using currentpicture the way one would in MetaPost (drawing in raw PostScript coordinates), you can simply do something like:
fill((0,0)--(100,100)--(200,0)--cycle);
pair center(picture pic=currentpicture) {return 0.5*(pic.min()+pic.max());}
real height=100;
real width=100;
pair delta=0.5(width,height);
pair c=center();
clip(box(c-delta,c+delta));
However, drawing in PostScript coordinates is often inconvenient. Here’s the Asymptote way of doing the same thing, using deferred drawing:
size(200,100);
fill((0,0)--(1,1)--(2,0)--cycle);
void clip(picture pic=currentpicture, real width, real height)
{
pic.clip(new void (frame f, transform) {
pair center=0.5(min(f)+max(f));
pair delta=0.5(width,height);
clip(f,box(center-delta,center+delta));
});
}
clip(100,100);
See also the discussion of tilings in the documentation: https://asymptote.sourceforge.io/doc/Pens.html.
It’s actually not on by default, unless you happen to be using Microsoft Windows (because that is what most Microsoft Windows users expect). Microsoft Windows users can turn this feature off with the command-line option -noV or by putting
import settings; interactiveView=false; batchView=false;
in their config.asy file. See https://asymptote.sourceforge.io/doc/Options.html.
If you have the ImageMagick convert program installed, simply type
asy -f jpg test.asy
Convert them to eps format and use the graphic(string) function just like a Label:
label(graphic("file"),(0,0));
See the example https://asymptote.sourceforge.io/gallery/orthocenter.asy and https://asymptote.sourceforge.io/doc/label.html.
Yes, PDF output can be produced by the -f pdf option or -tex pdflatex option. This supports transparency, annotations, embedded movies, and U3D/PRC content.
Try using some of the options to convert, mainly -geometry and -density. For example:
convert -geometry 1000x3000 example.eps example.png
You can also change the default resolution of the image with:
convert -geometry 1000x3000 -density 300 -units PixelsPerInch example.eps example.png
This does not change the number of pixels in the image, but just gives a hint as to how large each pixel should be displayed.
If you include the -density option without the -geometry option, convert will keep the image size constant (so a 4cm x 3cm eps figure will generate a 4cm x 3cm png image).
Yes, simply call the newpage() function. This is used by the slide.asy package to produce high-quality slide presentations (easier to use than Prosper).