In my opinion, the Olympiad.asy package contains some of the most important functions inside of Asymptote. First, we need to define what a package is.

If you've used pretty much any other coding language, you'll be familiar with what a package is. It's what you'd put in the import line at the top of your Python program, for example. A package is effectively a set of functions that can be used that don't automatically come with Asymptote - if you download Asymptote on your own computer, you'll have to separately download this package as well. AoPS handily comes with the Olympiad.asy package, though, so you don't need to do anything extra to use it on AoPS.

The Olympiad.asy package contains more functions that can be used to find points or paths without actually finding the coordinates of it. I'm just going to write out a list of all of the functions, as that's the easiest way to describe them.

(Incomplete) List of Olympiad.asy Functions
Generic Functions

• origin returns the pair . Example of origin
  
• foot(X, A, B) where , , and are pairs returns the foot of the altitude from to line . Example of foot
  
• midpoint(A--B) where and are pairs returns the midpoint of the segment . Note the two dashes between and instead of a comma. Example of midpoint
  

Intersections of Paths

• extension(A, B, C, D) where , , , and are pairs returns the point of the intersection of the lines and .Example of extension
  
• intersectionpoint(A, B) where and are paths returns the intersection of the paths and (similar to the extension function). NOTE: Unlike the extension function, this will throw an error if the paths do not intersect. Thus, if you're trying to intersect a segment and a circle that don't intersect, you won't get anything - you need to first find a point on that line farther than the other two and use that instead of the first one. NOTE2: If the paths and intersect at more than one point, this function will throw an error, and instead you should use the function in the next bullet point. If you're finding the intersection of two lines, it is better to use the first bullet point's function.Example of intersectionpoint
  
• intersectionpoints(A, B)[x] where and are paths and x is an integer returns the th intersection counter-clockwise of the paths and . NOTE: Unlike the extension function, this will throw an error if the paths do not intersect. Thus, if you're trying to intersect a segment and a circle that don't intersect, you won't get anything - you need to first find a point on that line farther than the other two and use that instead of the first one. NOTE2: If the paths and intersect only once, it is better to use the second bullet point's function.
  Example of intersectionpoints
  

Special Points of a Triangle

• circumcenter(A, B, C) where , , and are pairs returns the circumcenter of the triangle . Example of circumcenter
  
• incenter(A, B, C) where , , and are pairs returns the incenter of the triangle . Example of incenter
  
• orthocenter(A, B, C) where , , and are pairs returns the orthocenter of the triangle . Example of orthocenter
  
• centroid(A, B, C) where , , and are pairs returns the centroid of the triangle . Example of centroid
  

Practice Problems
No practice problems for this lesson (as this was more of a functional lesson).

This is part two of the customization series.

Sometimes, it's helpful to color a path or point, for example if you're modelling the path of a laser in a polygon, you may want to make the laser red. This lesson will tell you how to do that.

Coloring things. In essence, coloring something is very similar to labelling a point, but even easier. Again, you put an argument after the draw statement, like this:

draw(item, color);

Your color is going to be in words and all lowercase. For example, if you wanted to color a point red, you would do this:

dot((0, 0), red);

This will create this:

What if you wanted to label the point as well? The arguments must go in a specific order:

draw(label, item, label_direction, color);

For example, to label our dot earlier as point , you would do this:

dot("$A$", (0, 0), S, red);

which gives you this:

Notice how it also colors the label, so if you don't want the label to be colored, you must label the point after creating the object.

Marking right angles. Say you wanted to mark the measure of an angle. How would you do this? Asymptote has a package called the CSE5 package that contains a function to do this with (it also has the markangle() function in olympiad.asy, but we'll do that later). We won't cover this package at all because it's quite complex, but if you want to learn about it, you can do so in the AoPS Wiki found here.

However, marking right angles is quite simple. It's done using the rightanglemark() function. Here's the syntax:

draw(rightanglemark(first_vertex, vertex_of_right_angle, second_vertex, size));

This marks the angle with a mark of size "size." The rightanglemark() function creates a path that's the mark, so you need to use the draw() function on it. Example:

The funny thing is, you can actually use this for non-right angles:

Either way, it's handy to know. And that's the end of this lesson!

Practice Problems
1. Draw an equilateral triangle with 3 different colored sides - red, blue, and green. Solution
2. Draw a 45-45-90 right triangle and mark the 90 degree angle with a right angle mark. Solution

When coding in Asymptote, it's sometimes helpful to label a point or color a path or label. Asymptote has the ability to do either of those things, using special arguments and/or commands inside of a function.

Labeling Pairs and Paths
There are two main ways to label something. The first is to label it while creating the pair/path itself, the other is to label it afterwards.

Labelling while creating. To label a pair or a path while creating the pair/path itself, simply add another argument in front of all of the arguments of the draw function. The syntax looks like this:

draw("label", item);

Notice the quotes around the label - these indicate that the label is a string, a data type containing a sequence of characters.

If you wanted to label a point as , you would do this:

dot("$A$", (0, 0))

Notice that you need dollar signs around the A just as in .

This will look like this:


Notice what happens we draw another line, as follows:

The line can go straight through the label. To fix this, add another argument. This argument will tell Asymptote where to draw the label relative to your new point.

draw("label", item, direction);

To specify the direction of the label, use the

dir()

function. In the following example, we will use

dir(180)

to make the label appear directly left of the point.


Labelling afterwards. This is very similar to labelling while creating. SImply use the label command after creating the object:

draw(item);
label("label", item, direction);

Practice Problems
1. Label the point (0, 0) as point upwards directly while drawing. Solution
2. Label the point (0, 0) as point to the right and down after drawing. Solution

This lesson will cover the dir() function, which, due to it's immense importance, will get a lesson of it's own. It will be slightly shorter due to the fact a) the function really isn't that hard, and b) most of the advanced commands are in the olympiad.asy package which is coming in a later lesson.

The dir() Function. The dir() function is a very useful function that allows you to draw points using angles rather than coordinates. If you know what polar coordinates are, the dir() function runs off of them, effectively. If you look at this diagram, you'll see a preview of how it works:

The dir() function creates a point that is of a certain angle counterclockwise from the point (1, 0) of distance 1 from the origin. The syntax is as follows:

dir(direction);

where the direction is measured in degrees. For example,

// the lines draw the axis, so they don't affect the dir
// ignore the lines with the backslashes, they're called comments and we'll get to them later
draw((-2, 0)--(2, 0));
draw((0, -2)--(0, 2));
dot(dir(50));

creates

As you can see, the dot created is 50 degrees counterclockwise of the x-axis. This is particularly useful when creating triangles with certain angle measures, such as 30-60-90s (which we'll leave as an exercise for a later lesson ).

Note: you're also able to put negative angle measures in the argument of the dir() function, which will measure the angle clockwise rather than counterclockwise.

The dir() function comes as a pair, so when creating a variable, you'd want to do this:

pair variableName = dir(direction);

If you want the length of your function to be longer or shorter than just 1 unit, you can multiply your dir() function by a number, such as this:

pair point = sqrt(2)*dir(50);

Practice Problems
Problem 1: Draw a dot that is 37 degrees counterclockwise from the origin. Solution

In Asymptote, it's quite handy to name variables, whether it's for a value, for a point, or for a path. This is useful because you may need to use a point many times - with variables, instead of needing to type the coordinates every single time, you can just create a variable once and use the variable instead.

Next, we need to learn how to create a variable. The syntax is simple:

variableType variableName = variableValue;

I'm going to break this up into three parts: the variable type, name, and value.

If you've learned Java or something similar to it, you'll know what the variable type is. When creating a variable, Asymptote needs to know what kind of variable you're creating - for example, the four main types I'm going to be going over in this tutorial are ints, reals, pairs, and paths. We'll get to that soon.

The variable name is the name of the variable you're creating. This is effectively it's identifier - just as we identify each other by our names, Asymptote identifies variables by their names. NAMES CAN BE ANYTHING, BUT CANNOT CONTAIN SPACES.

The variable value is what is being stored inside that value, which you retrieve by referring to its name. We'll get to that soon.

Creating Variables
Ints. Other languages such as Java also have this data type. It's name is quite self-explanatory, the int stands for integer - in this kind of data type, you can store any integer you want, such as 5, -2, or 18430. To create an int, all you need to do is type this:

int variableName = integerValue;

The variableName is what you want to call this variable - try to call it something that makes sense. For example, if it's the x-coordinate of a point, you may want to call it x_coor.

Reals. If you want to create a variable that stores a real number but isn't an integer, use the real type. Just like ints, the syntax is as follows:

real variableName = numberValue;

If you know Python, reals are somewhat similar to floats in a sense. It can contain numbers such as 5, 5.5, or 3.141592 (note that you can store an int inside of a real).

Pairs. A pair is a data type that stores a coordinate pair. This is the data type that I use the most frequently in Asymptote, as Asymptote uses a coordinate system to tell where you want to draw. The syntax is as follows:

pair variableName = (xCoord, yCoord);

Note that you must use parenthesis around your variable value, or Asymptote will error.

Paths. A path is a drawing, such as a line or circle. This variable type is more open-ended, but the basic syntax is like this:

path variableName = variableValue;

For example, to create a variable containing a circle, you would do

path circle = circle((center_x, center_y), radius);

And to create a line,

path line = (x_1, y_1) -- (x_2, y_2);

Additionally, if you want to create multiple variables of the same type in a row, you can do this:

variableType name1 = value1, name2 = value2, name3 = value3;

where name1, name2, and name3 are the names of the variables and value1, value2, and value3 are the values of the variables respectively (you can create more or less than just 3 variables in one line).

Using Created Variables
To use a created variable, all you need to do is put the variable name wherever you want its value to be used. For example, you could do this:

pair center = (0, 0);
int radius = 5;
path circle = circle(center, radius);
draw(circle);
dot(center);

which would give you this
Notice how I use a variable inside the creation of another variable.

Practice Problems
Problem 1: Create a variable of type int with name radius and value 5, and draw a dot using that variable at (radius, radius). Solution
Problem 2: Create 2 pairs in one line: one with coordinates (1, 2) and the other with coordinates (3, 1). Draw a line between those two points with the variables. Solution
Problem 3: Create a variable of type path that contains a circle with center (4, 1) and radius 2. Draw that circle. Solution

In this lesson, we'll introduce the basics to drawing, including points, lines, and circles. However, before we do the drawing, we have to learn some universal syntax expectations that Asymptote will throw an error if not done correctly.

1. All lines you write must end with a semicolon, or a ;. If not included at the end of a single line, your program will not run and will fail to generate the diagram you are trying to create.
2. If you haven't ever learned another coding language, you need to be careful that your parenthesis match up. If you are missing an opening or closing parenthesis, the code will not run.

Alright, let's get into the drawing.

Drawing Points. A point is probably the most basic command in Asymptote, and yet it is quite important. Here is the syntax:

dot((x-coordinate, y-coordinate));

Note a couple things. Firstly, the line ends with a semicolon, which all Asymptote must. Second, there are 2 pairs of parenthesis. Why? you may ask. This is because there are two layers. The first pair of parenthesis, or the bolded ones: dot((x, y)); are there because this is a function. You'll be familiar with a function if you have used any other coding language, but if you haven't, all you need to know is that the functions are the stuff that draws stuff in Asymptote.

With this function, you'll see that inside of the parenthesis is the argument, or the input. Without this input, the function won't be able to run - in the case of drawing points, it needs the coordinates of where you want to draw the points. Otherwise, the program won't know where the point should be drawn. This is the second pair of parenthesis - they are part of the input, or the coordinates. Whenever you write down a coordinate pair, you need parenthesis around them (for example (0, 0), or the origin), and Asymptote is no different.

There are more optional arguments for this function, but that's for a later lesson.

This diagram, when run, should look like this.

Drawing Lines. Lines are quite similar to points: they have a function, and inside that function they have one single argument. Well, technically Asymptote doesn't draw lines. They draw line segments, as the lines are not infinite and have endpoints. The syntax is as follows:

draw((x-coor-1, y-coor-1)--(x-coor-2, y-coor-2));

Instead of the function dot, we use the function draw. This time, we also have two points: the two endpoints of the line, and 2 horizontal dashes separating the points.

When draw, the diagram looks like this. I just picked two random endpoints for my line, your line's direction/length will probably be different.

Drawing Circles. Circles, like lines, use the draw function. However, unlike lines, you need to specify as an argument that you are drawing a circle. The syntax is like this:

draw(circle((center-x, center-y), radius));

Here, you have 1 single argument: the circle. However, as we'll learn later the circle is something called a path, which, like a point, is a type of object. Therefore, you can put this circle inside of the draw by itself.

However, inside of the circle, you still need to specify the center and radius, as without it, Asymptote will not know how to draw the circle.

Once drawn, the diagram should look like this. Again, my circle was chosen randomly, so your circle may look different.

That's it for this lesson! There are a couple problems this week, so if you find yourself needing extra practice, you can do them .

Practice Problems
Problem 1: Draw a point at the coordinates (1, 2). Solution
Problem 2: Draw a line with endpoints (4, 5) and (8, 2). Solution
Problem 3: Draw a circle with center (-3, 2) and radius 4. Solution

How do I make graphs like this?, you may ask. The answer: Asymptote, a vector graphics language that allows you to draw neat geometry diagrams in your proof. AoPS handily allows Asymptote to be embedded inside of posts just like , so you can try out programs right here on AoPS .

This blog is going to be a blog where I post lessons for beginners. If you don't know a single thing about Asymptote, that's OK! I'm going to be starting with the basics.

Additionally, at the end of every lesson, there are going to be a couple practice problems with the solutions. If you find yourself needing more practice, you can just try out those problems. Also, don't be afraid to ask for help in the shoutbox!

Let's get started!