Programming for Architecture

1 Preface

This book was born in 2007, following an invitation to teach an introductory programming course to architecture students at Instituto Superior Técnico (IST). The original motivation for this course was the same as for several other courses: just like Mathematics and Physics, Programming has become one of the fundamental courses that constitute the basic education of any IST student.

With this premise, it did not seem to be a subject that would entice the student’s interest, particularly since it was not very clear the contribution it could have to the architectural curriculum. To contradict that first impression, I decided to include in the course’s syllabus some applications of Programming in Architecture. To that end, I had a conversation with several architectural students and teachers and asked them to explain to me what they did and how they did it. What I heard and saw was revealing.

Despite the enormous progresses that Computer-Aided-Design (CAD) and Building Information Modeling (BIM) brought to the profession, the truth is that its use continues to be manual, laborious, repetitive and boring. The creation of a digital model in a CAD or BIM tool requires extreme attention to detail, distracting the architect from what is fundamental: the idea. Frequently, the obstacles found end up forcing the architect to simplify the original idea. To make things worse, the obstacles do not end when the model is finally created. On the contrary, they become aggravated when inevitable design changes need to be made to that model.

In general, CAD and BIM tools are conceived to make the most common tasks easier, in detriment of other less common or sophisticated tasks. In fact, for an architect interested in modeling more complex shapes, the tools used can present several limitations. However, those limitations are only deceptions since they can be overcome with the aid of programming. Programming allows a CAD or BIM tool to be amplified with new capabilities, thus eliminating the obstacles that hinder the architect’s design process.

The programming practice is intellectually stimulating but it is also very challenging. Not only does it require mastering a new language, but it also implies a new way of thinking, an effort that, frequently, makes people give up. Nevertheless, those that prevail overcome the initial difficulties and acquire the skills to go further in the creation of innovative architectural solutions.

This book is meant for those architects.

2 Introduction

Throughout history, humanity has accumulated enormous amounts of knowledge. That knowledge is of extreme importance for our survival and, therefore, needs to be passed to the following generations. To this end, a series of mechanisms were invented. Firstly, oral transmission, from one person to a small group of people. Secondly, written transmission, consisting in documenting knowledge. This approach has the great advantage of reaching out to a much larger group of people and of significantly reducing the risk of knowledge loss. In fact, the written word allows us to preserve knowledge for long periods of time, safe from the inevitable corruption that occurs on a long chain of oral transmissions.

It is thanks to the written word that mankind can understand vast amounts of knowledge, some of which date back thousands of years. Unfortunately, the written word has not always been able to accurately transmit what the author had in mind. The natural language is ambiguous and it evolves with time, making the interpretation of written texts a subjective task: there are omissions, imprecisions, errors, and ambiguities, both when we write a text and when we read it, which can turn knowledge transmission into a fallible endeavor.

When rigor is needed in the transmission of knowledge, relying on the receptor’s abilities to understand it can have disastrous outcomes. In fact, throughout history we can find many catastrophic events caused solely by insufficient or incorrect transmission of knowledge. To avoid these problems, more accurate languages were invented. Mathematics, in particular, has obsessively been seeking to construct a language of absolute rigor over the past millennia. This allows for a much more accurate transmission of knowledge than in other areas, but it still requires a human to understand it.

To better understand this problem, let us consider one concrete example: the calculus of the factorial of a number. If we assume that the person to whom we want to transmit that knowledge knows beforehand the meaning of numbers and arithmetic operations, we could tell him that, to calculate the factorial of a number, one must multiply every number from one until that number. Unfortunately, that description is inaccurate, because it does not state that only integer numbers are to be multiplied. To avoid these imprecisions and simultaneously make the information more compact, Mathematics developed a set of symbols and concepts that should be understood by everyone. For example, to define the integer sequence of numbers between \(1\) and \(9\), Mathematics allows us to write \(1,2,3,\ldots,9\). In the same manner, instead of referring to a number, Mathematics invented the concept of variable: a name that refers to some “thing” that can be used in several parts of a mathematical statement, always representing the same “thing”. In this way, Mathematics allows us to more accurately express the factorial computation as follows:

\[n! = 1\times 2\times 3\times \cdots{} \times n\]

But is this definition rigorous enough? Is it possible to interpret it without guessing the author’s intention? For a human being, maybe. However, if we want to be as rigorous as possible, then we must admit that there is one detail in this definition that requires some imagination: the ellipsis. The ellipsis indicates that the reader must imagine what should be in its place. Although most readers will correctly understand that the author meant the multiplication of the subsequent numbers, some might think to replace the ellipsis with something else.

Even if we exclude this last group of people from our target audience, there are still other problems with the previous definition. Let us imagine, for example, the factorial of \(2\). What will be its value? If we use \[n = 2\] in the formula, we get:

\[2! = 1\times 2\times 3\times \cdots{} \times 2\]

In this case, the computation makes no sense, which shows that, in fact, imagination is needed for more than just understanding the ellipsis: the number of terms to consider depends on the number to which we want to calculate the factorial.

Assuming that our reader has enough imagination to figure out this particular detail, he would easily calculate that \(2!=1\times 2=2\). But even so, there will be cases where it is not that clear. For example, what is the factorial of zero? The answer does not appear to be obvious. What about the factorial of \(-1\)? Again, it is not clear. And the factorial of \(4.5\)? Once again the formula says nothing regarding these situations and our imagination cannot guess the correct procedure.

Would it be possible to find a way of transmitting the knowledge required to compute the factorial function that minimizes imprecisions, gaps, and ambiguities? Let us try the following variation of the factorial function definition:

\[n!= \begin{cases} 1, & \text{if $n=0$}\\ n \cdot (n-1)!, & \text{if $n\in \mathbb{N}$.} \end{cases}\]

Have we reached the necessary rigor that dispenses imagination on the reader’s part? One way to find out is to reanalyze the cases that had previously caused problems. First of all, there is no ellipsis, which is positive. Secondly, for the factorial of the number \(2\), we have:

\[2!=2\times 1!=2\times (1\times 0!)=2\times (1\times 1)=2\times 1=2\]

which means that there is no ambiguity. Finally, we can see that it makes no sense trying to determine the factorial value of \(-1\) or \(4.5\) because this function can only be applied to \(\mathbb{N}_0\) members.

This example shows that, even in Mathematics, there are different levels of rigor in the different ways of expressing knowledge. Some require more imagination than others but, in general, they have been enough for mankind to preserve knowledge throughout history.

This state of affairs changed in the last decades: mankind has now a partner which has been giving an enormous contribution to its progress: the computer. This machine has the extraordinary capability of being instructed on how to execute a complex set of tasks. Programming is essentially all about transmitting to a computer the knowledge needed to solve a specific problem. This knowledge is called a program. Because they are programmable, computers have been used for the most diversified ends and they have radically changed the way we work. Unfortunately, the computer’s extraordinary ability to learn comes with an equally extraordinary lack of imagination. A computer does not assume or imagine, it just rigorously interprets the knowledge transmitted in the form of a program.

Since it has no imagination, the computer depends critically on the way we present it the knowledge that we wish to transmit, which must be described in a language that allows for no ambiguity, gaps, or imprecision. A language with these characteristics is generally called a programming language.

2.1 Programming Languages

For a computer to be able to solve a problem it is necessary to describe the process of solving the problem in a language that it understands. Unfortunately, the language that a computer “innately” understands is extremely poor, making the description of how to solve a non-trivial problem a very exhausting, tedious and complex task. The countless programming languages that have been invented aim at alleviating the programmer’s burden, by introducing linguistic elements capable of simplifying those descriptions. For example, the concepts of function, sum, matrix or rational number do not exist natively in computers but many programming languages allow their usage in order to simplify the description of scientific calculus. Naturally, this implies a process that transforms the programmer’s descriptions into instructions that computers can understand. This process is called compilation and although it is relatively complex, we only need to know that it allows us to use programming languages that are closer to the thinking capabilities of humans, than those of computers.

Compilation is of extreme importance because it allows us to use programming languages not only to instruct a computer on how to solve a problem, but also to explain that process accurately to another human being. In this way, much like Mathematics, programming languages become a way of transmitting knowledge and, in fact, they are even more rigorous than Mathematics.

There is a great diversity of programming languages, some better equipped than others to solve specific problems. This means that choosing a programming language should depend on the kind of problems we wish to solve, but it should not be a full commitment. For a programmer, it is much more important to understand the fundamentals and techniques of programming than to master one language or another. However, to better understand these fundamentals, it is convenient to exemplify them in a concrete programming language.

As this document will focus on programming for architecture, we will use a programming language that is geared towards solving geometrical problems. There are many languages that serve this purpose, most commonly associated with Computer Aided Design (CAD) or Building Information Modeling (BIM). ArchiCAD, for instance, offers a programming language called GDL, an acronym for Geometric Description Language that enables users to program multiple geometric forms. In the case of AutoCAD, the language used is called AutoLisp, a dialect of a famous programming language called Lisp. A third option is the RhinoScript language, available for Rhinoceros 3D. Despite these languages seeming very different from each other, the concepts behind them are very similar. These fundamental concepts of programming will be the main focus of our study. However, for pedagogical reasons, it is convenient to address them in a single language.

Unfortunately, GDL, AutoLisp, and RhinoScript were developed many years ago and they have not been updated, possessing many archaic characteristics that make them harder to learn and use. In order to ease the learning process while allowing our programs to run in different CAD environments, we are going to use a new language called Julia, which was purposely adapted for programming in architecture. Julia is freely available at https://julialang.org/. In this text we will explain the fundamentals of programming using Julia, not just because it is easier to learn, but also for its practical applicability. However, once learned, the reader should be able to apply these fundamentals to any other programming language.

In order to facilitate the programmer’s task, Julia can be used from a programming environment called Atom, which offers a text editor adapted to edit Julia’s programs, as well as a set of additional tools for error detection and debugging. This programming environment is shared with a freeware license and it is available at https://atom.io/.

2.1.1 Exercises 1

2.1.1.1 Question 1

Exponentiation \(b^n\)is an operation between two numbers \(b\) and \(n\). When \(n\) is a positive integer, exponentiation is defined as:

\[b^n = \underbrace{b \times b \times \cdots \times b}_n\]

To a reader not familiarized with exponentiation, the previous definition raises several questions that may not be evident: how many multiplications should actually be done? \(n\)?, \(n-1\)? What if \(n=1\)? Or \(n=0\)? Propose a definition for the exponentiation function that raises none of these questions.

2.1.1.2 Question 2

What is a program and what purpose does it serve?

2.1.1.3 Question 3

What is a programming language and what purpose does it serve?

2.2 The Julia Language

In this section we will learn about Julia programming language, which we will use throughout this text. But first, we are going to examine some aspects that are common to other languages.

2.2.1 Syntax, Semantics and Pragmatics

Every language has syntax, semantics, and pragmatics.

In simple terms, syntax is a set of rules that dictate the kind of sentence that can be written in a language. Without it, any concatenation of words could be a sentence. For example, given the words “John”, “cake”, “ate”, and “the”, the syntax rules of the English language tell us that - “John ate the cake” is a correct sentence, and that - “the ate cake John” is not. It is also important to note that, according to the English syntax, “The cake ate John” is also syntactically correct. This means that syntax is not enough to completely specify the rules of a language. In fact, syntax dictates how a sentence is constructed but says nothing in regards to its meaning. That is the job of semantics, which attributes meaning to a sentence, thus telling us that “The cake ate John” makes no sense. Finally, pragmatics sets the way sentences are commonly expressed. In a language, pragmatic changes depending on the context: the way two close friends talk with each other is different from the way two strangers talk.

These three aspects of a language are also present when we discuss programming languages. Unlike the natural languages we use to communicate between us, programming languages are characterized as being formal, obeying a set of simple and restrictive rules that can be mechanically processed.

In this document we will describe Julia’s syntax and semantics and, although there are mathematical formalisms to describe rigorously those two aspects, they require a mathematical sophistication that, given the nature of this work, is inappropriate. Hence, we will only use informal descriptions. Afterwards, as we introduce language elements, we will discuss the language pragmatics.

2.2.2 Syntax and Semantics of Julia

Compared to other programming languages, Julia’s syntax is simple and is based on the concept of expression.

An expression in Julia can be formed using primitive elements, such as numbers, or by the combination of those elements using an operation, such as the sum of two numbers. This simple definition allows us to build expressions of arbitrary complexity. However, it is important to remember that syntax restricts what can be written: the fact that we can combine expressions to create more complex ones does not mean we can write any combination of expressions. These combinations are restricted by syntactic rules, which we will describe throughout this text.

Much like syntax, Julia’s semantics is also simple when compared to other programming languages. As we will see, semantics is determined by the operators that are used in our expressions. For instance, the sum operator is used to add two numbers. An expression that combines this operator with, for example, the numbers \(3\) and \(4\) will have as meaning the sum between \(3\) and \(4\), i.e., \(7\). In a programming language, the semantics of an expression is given by the computer when it evaluates the expression.

2.2.3 The Evaluator

Every expression in Julia has a value. This concept is so important that Julia provides an evaluator, i.e., a program designed to evaluate expressions.

In Julia, the evaluator is shown as soon as we start working with the language. Once Julia is running, the user is presented with the text julia> (called prompt), meaning that Julia is waiting for the user to input an expression. Julia interacts with the user by executing a cycle that reads an expression, determines its value, and writes it. This cycle is traditionally called read-eval-print loop (abbreviated to REPL).

During the read phase, Julia reads an expression. In the evaluation phase, that expression is analyzed in order to produce a value. This analysis uses rules that dictate, for each case, the expression value. Finally, in the print phase, this value is printed so that the user can see it.

The existence of the read-eval-print loop makes Julia an interactive language that allows programs to be quickly developed by writing, testing, and correcting small fragments at a time.

2.3 Language Elements

In every programming language we have two important concepts: data and procedures. Data comprise the entities that we wish to manipulate. Procedures describe how to manipulate those entities.

In Mathematics, we can look at numbers as the data and at algebraic operations as the procedures. These operations allow us to combine numbers. For example, \(2\times 2\) is a combination. Another combination involving more data is \(2\times 2\times 2\), and using even more data \(2\times 2\times 2\times 2\). However, unless we want to spend time solving problems of elementary arithmetic, we should consider more elaborate operations that represent combination patterns. In the previous sequence of combinations, it is clear that the pattern emerging is the concept of exponentiation, which has been defined in Mathematics a long time ago. Exponentiation is therefore an abstraction of a succession of multiplications.

As in Mathematics, a programming language should contain data and procedures, should be capable of combining data and procedures to create more complex data and procedures, and should be able to abstract patterns, allowing the definition of new operations that represent those patterns.

Further ahead we will see how to define these abstractions in Julia. For now, let us take a closer look at the primitive elements of the language, i.e., the simplest entities that the language deals with.

2.3.1 Numbers

Numbers are one of the most primitive elements of Julia. Julia provides integers, fractions, reals, and other kinds of numbers. The syntax of the language includes different ways for the user to write those different kinds of numbers. Regarding semantics, numbers are very simple to evaluate: the value of a number is the number itself. For example, the value of 1 is 1.

In Julia, numbers can be exact or inexact. Exact numbers include integers, fractions and complex numbers with integer parts. Inexact numbers are all others, typically written in decimal or scientific notation, such as \(123.45\) or \(1.2345e2\).

2.4 Combinations

A combination is an expression that describes the application of an operator to its operands. For example, numbers can be combined using operations like the sum or product, e.g. \(1 + 2\) and \(1 + 2 \times 3\). The sum and product of numbers are two of the most primitive procedures provided by Julia. Naturally, many other operations can be used, including mathematical functions such as sine (\(\sin\)) or cosine (\(\cos\)). The syntax for functions, however, is slightly different: unlike arithmetic operators, like sum and product that use infix syntax, i.e., the operator appears between the operands, functions use prefix syntax, i.e., they appear before the operands, as in \(\sin 2\). Finally, there are also operators, such as factorial (abbreviated \(!\)) that are used with postfix syntax, as in \(5 !\).

In Julia, a combination can be created using a syntax similar to the one used in Mathematics, although with some small differences: functions are written in prefix syntax but function arguments are grouped with parentheses, as in sin(2). Arithmetic operators can also be treated as functions, as in +(1,2) but they are usually written using infix syntax, as in 1+2. In Julia, an expression is a primitive element or a combination of expressions with an operation. The expression 1+2 is a combination of the two primitive elements 1 and 2 through the primitive procedure +. In the case of 1+2*3, the combination is between the number 1 and the combination 2*3 because Julia follows the same precedence rules used in Mathematics. Therefore, the expression 1+2*3 is interpreted as 1+(2*3).

2.4.1 Exercises 2

2.4.1.1 Question 4

Explain the acronym REPL.

2.4.2 Evaluating Combinations

The evaluator determines a combination’s value by applying the procedure specified by the operator to the value of the operands. The value of an operand is designated as the argument of the procedure. The value of the combination 1+2*3 is the result of adding the value of 1 to the value of 2*3. As we have already seen, the value of 1 is \(1\) and 2*3 is a combination whose value is the result of multiplying 2 by 3, which is \(6\). Finally, by summing \(1\) with \(6\) we get \(7\).

> 2*3

6

> 1+2*3

7

2.4.3 Strings

Chains of characters (also called Strings) are another type of primitive data. A character is a letter, a digit or any kind of graphic symbol, including non-visible graphic symbols like blank spaces, tabs and others. A string is specified by a character sequence between quotations marks. Just like with numbers, the value of a string is the string itself:

> "Hi"

"Hi"

> "I am my own value"

"I am my own value"

Since a string is delimited by quotation marks, how can we create a string that contains quotation marks? For this and other special characters, there is one particular character that Julia interprets differently: when the character \ appears in a string, it tells Julia that the next characters must be evaluated in a special way. For example, to create the following string:

John said "Good morning!" to Peter.

We must write:

"John said \"Good morning!\" to Peter."

The character \ is called an escape character and allows the inclusion of characters in strings that would otherwise be difficult to input. This table shows examples of other special characters that need to be escaped.

Some valid escape characters in Julia.

Sequence		Result
\\		the character \ (backslash)
\"		the character " (quotation marks)
\n		new line character (newline)
\r		new line character (carriage return)
\t		tab character (tab)

As it happens with numbers, there are countless operators to manipulate strings. For example, to concatenate multiple strings we can use the * operator. The concatenation of several strings produces a single string with all the characters of those strings, in the same order:

> "1"*"2"

"12"

> "one"*"two"*"three"*"four"

"onetwothreefour"

> "I"*" "*"am"*" "*"a"*" "*"string"

"I am a string"

> "And I"*" am "*"another"

"And I am another"

To know how many characters there are in a string we have the length operator:

> length("I am string")

11

> length("")

0

Note that quotation marks define strings’ boundaries and are not considered characters. Besides strings and numbers, Julia has other kinds of primitive elements that will be addressed later.

2.5 Defining Functions

Mathematics offers a large set of operations that are defined based on the most basic ones. For example, the square of a number is an operation (also designated as a function) that, given a number, multiplies that number by itself. This function has the following mathematical definition:

\[x^2 = x \cdot x\]

Like in Mathematics, it is possible to define the square function in a programming language. In Julia, to obtain the square of the number 5, we write the combination 5*5. In general, given a number x, we square it by writing x*x. All that is left to do is associate a name indicating that, given a number x, we obtain its square by evaluating x*x. This is done in Julia as follows:

square(x) = x*x

As you can see from the square function definition, in order to define a function in Julia, we need to use the following syntax:

The function’s parameters are called formal parameters, and they are used in the body of the function to refer to the corresponding arguments. When we write square(5) in the evaluator, the number 5 is the argument of the function. During the calculation this argument is associated with the parameter x. The arguments of a function are also called actual parameters.

The definition of the square function declares that, in order to determine the square of a number x, we should multiply that number by itself (x*x). This definition associates the word square with a procedure, i.e., a description on how to obtain the desired result. Note that this procedure has parameters allowing its use with different arguments. As an example, we will evaluate the following expressions:

> square(5)

25

> square(6)

36

The previously explained rule to evaluate combinations is also valid for combinations that invoke user-defined functions. The evaluation of the expression square(1+2) first evaluates the 1+2 argument. The resulting value, \(3\), will then replace parameter x in the function. This means that the function’s body is evaluated with all occurrences of x replaced by the value 3 and, therefore, the final value will be the value of the combination 3*3, i.e., 9.

Formally, in order to invoke a function, one must construct a combination in which the first element is an expression whose value is the function we want to invoke, and the remaining elements are expressions whose values are the arguments that the function is supposed to use. The result of the combination’s evaluation is the value calculated by the function for those arguments.

The process of evaluating a combination follows three essential steps:

1. All elements in a combination are evaluated. The value of the first element must be a function.

2. The formal parameters are associated to the function’s arguments, i.e., the value of the remaining elements of that combination. Each parameter is associated to an argument, according to the order of parameters and arguments. An error occurs when the number of parameters does not match the number of arguments.

3. The function’s body is evaluated while considering the associations between parameters and arguments.

To better understand this process, it is useful to break it down to its most elementary steps. The following example shows the process of evaluating the expression \(((1+2)^2)^2\) step by step:

square(square(1+2))

\(\downarrow\)

square(square(3))

\(\downarrow\)

square(3*3)

\(\downarrow\)

square(9)

\(\downarrow\)

9*9

\(\downarrow\)

81

Julia does not distinguish between predefined functions and functions created by the user. This means that, just like predefined functions, user-defined functions can be used to create new functions. For example, after defining the square function, we can define the function that calculates the area of a circle with radius \(r\), using the formula \(\pi * r^2\):

circle_area(radius) = pi*square(radius)

Naturally, during the evaluation of the expression that computes the area of a circle, the square function is invoked. This is visible in the following evaluation sequence:

circle_area(2)

\(\downarrow\)

pi*square(2)

\(\downarrow\)

3.14159*square(2)

\(\downarrow\)

3.14159*2*2

\(\downarrow\)

3.14159*4

\(\downarrow\)

12.5664

Defining a function causes an association between a procedure and a name. In order to retrieve this association whenever the function is being used, Julia needs to store the association in the computer’s memory. The memory that contains these associations is called the evaluation environment.

Note that this environment exists only while we are using the program. When the program is shut down, that environment is lost. In order to avoid losing those definitions, they should be saved in a file. This means that, despite the usefulness of the REPL for testing the definitions, these should be written in files to preserve them for future use. Fortunately, programming environments, such as Atom, facilitate this workflow.

2.5.1 Exercises 3

2.5.1.1 Question 5

Define the function double, which calculates the double of a given number.

2.6 Names

Defining a function involves assigning names, not only for the function itself, but also for its parameters.

In Julia, there are a few restrictions regarding names: they must begin with a letter, the underscore character, or a Unicode symbol (in practice, only a subset of Unicode is allowed). The remaining characters can also include !, digits and many more Unicode symbols. However, note that it is not possible to use names that are already reserved by the language. We will see some of them soon.

Pragmatically speaking, the creation of names should take some rules into consideration:

• Avoid using digits, if possible.

• For portability reasons, accented characters should be avoided.

• If a name has more than one word, those words should be concatenated or, when the result is difficult to understand, the names should be separated by an underscore (_). For example, a function that computes the area of a circle might be named circle_area.

The choice of names will have a significant impact on the program’s legibility. Let us consider for example the area \(A\) of a triangle with base \(b\) and height \(c\), which can be defined mathematically by:

\[A(b,c) = \frac{b \cdot c}{2}\]

In Julia we will have:

A(b, c) = (b*c)/2

Note that the Julia definition is identical to the corresponding mathematical expression. However, if we did not know beforehand what the purpose of this function was, we would hardly understand it just by looking at its name and/or at the names of the parameters. Therefore, and contrary to Mathematics, the names that we assign in Julia should have a clear meaning. Instead of writing "A", it is preferable that we write "triangle-area" and, instead of writing "b" and "c", we should write "base" and "height", respectively. Taking these aspects into consideration, we can present a more meaningful definition:

triangle_area(base, height) = (base*height)/2

As the number of definitions grow, names become particularly important for the reader to quickly understand the written program, so it is crucial that names are carefully chosen.

2.6.1 Exercises 4

2.6.1.1 Question 6

2.6.1.2 Question 7

Define the function radians_from_degrees that receives an angle in degrees and computes the corresponding value in radians. Note that \(180\) degrees are \(pi\) radians.

2.6.1.3 Question 8

Define the function degrees_from_radians that receives an angle in radians and computes the corresponding value in degrees.

2.6.1.4 Question 9

Define a function that calculates the perimeter of a circle given its radius.

2.6.1.5 Question 10

Define a function that calculates the volume of a parallelepiped from its length, width and height.

2.6.1.6 Question 11

Define a function that calculates the volume of a cylinder from its height and base radius. The volume corresponds to multiplying the area of the base by the cylinder’s height.

2.6.1.7 Question 12

Define a function average that calculates the average value between two numbers. For example: average(2, 3) \(\rightarrow\) 2.5.

2.7 Predefined Functions

The possibility of defining new functions is fundamental for increasing the language’s flexibility and its ability to adapt to the problems we want to solve. The new functions, however, must be defined in terms of others that were either defined by the user or, at most, predefined in the language.

As we will see, Julia has a vast set of predefined functions. In many cases, they suffice for what we want to do. Nevertheless, we should not restrain from defining new functions whenever we deem it necessary.

Some mathematical functions predefined in Julia.

Function		Arguments		Result
abs		A number		The absolute value of the argument.
sin		A number		The sine of the argument (in radians).
cos		A number		The cosine of the argument (in radians).
atan		One or two numbers		With only one argument, the arc tangent of the argument (in radians). With two arguments, the arc tangent of the division between the first and the second, where the sign of the arguments is used to determine the quadrant.
sqrt		A number		The square root of the argument.
exp		A number		The exponential value with base \(e\) of the argument.
^		Two numbers		The first argument raised to the power of the second argument.
log		One or two arguments		With one argument, the natural logarithm of the argument. With two arguments, the logarithm of the second argument with the first argument as its base.
max		Multiple Numbers		The highest argument.
min		Multiple Numbers		The lowest argument.
round		A number		Rounds the argument to the nearest integer.
floor		A number		Rounds down the argument to the nearest integer.
ceil		A number		Rounds up the argument to the nearest integer.

Julia’s predefined math functions.

Julia		Mathematics
abs(x)		\(|x|\)
sin(x)		\(\sin x\)
cos(x)		\(\cos x\)
atan(x)		\(\arctan x\)
atan(y, x)		\(\arctan \frac{y}{x}\)
sqrt(x)		\(\sqrt{x}\)
exp(x)		\(e^x\)
x^y		\(x^y\)
log(x)		\(\log_e x\)
floor(x)		\(\lfloor x\rfloor\)
ceil(x)		\(\lceil x\rceil\)

2.7.1 Exercises 5

2.7.1.1 Question 13

2.7.1.2 Question 14

2.7.1.3 Question 15

Define the function odd that, for a given number, evaluates if it is odd, i.e., if the remainder of that number when divided by two is one.

2.7.1.4 Question 16

The area \(A\) of a pentagon inscribed in a circle of radius \(r\) is given by the following expression: \[A = \frac{5}{8}r^2\sqrt{10 + 2\sqrt{5}}\] Define a function that calculates this area and test it with values of your choice.

2.7.1.5 Question 17

Define a function that calculates the volume of an ellipsoid with semi-axes \(a\), \(b\) and \(c\). This volume can be obtained by using the formula: \(V=\frac{4}{3}\pi a b c\)

2.8 Arithmetic in Julia

Julia is capable of dealing with several types of numbers, from integers to complex numbers, as well as fractions. Some of those numbers, like \(\sqrt 2\) or \(pi\), do not have a rigorous representation based in numerals and, for that reason, Julia classifies them as inexact numbers to emphasize the fact that we are dealing with an approximate value. When an inexact number is used in an arithmetic operation, the result will also be inexact, so the inexactness is said to be contagious.

Finitude is another feature of some types of numbers, meaning that those numbers cannot surpass a certain limit, above which every number is represented by infinity, as you can see by the following example that uses inexact numbers:

> 10.0^10

1.0e10

> 10.0^100

1.0e100

> 10.0^1000

Inf

Note that Inf (or -Inf) is Julia’s way of saying that a number exceeds the representation capacity. The number is not infinite, as one might think, but merely a value excessively big.

There is also another problem regarding inexact numbers: round-off errors. As an example, consider the obvious equality \((4/3-1)*3-1=0\) and note its result in Julia:

> (4/3-1)*3-1

-2.220446049250313e-16

As is possible to see, we did not obtain the correct result due to representation and round-off errors: 4/3 cannot be represented with a finite number of digits. This round-off error is then propagated to the remaining operations, producing a value that is not zero but is close to zero.

2.8.1 Exercises 6

2.8.1.1 Question 18

Translate the following definition to Julia: \[f(x)=x-0.1\cdot{}(10\cdot{}x-10)\]

2.8.1.2 Question 19

In mathematical terms, whatever the argument used in the previously mentioned function is, the result should always be \(1\), since \[f(x)=x-0.1\cdot{}(10\cdot{}x-10)=x-(x-1)=1\] Using the function defined in the previous exercise, evaluate the following expressions and explain the results:

f(5.1)

f(51367.7)

f(176498634.7)

f(1209983553611.9)

f(19843566622234755.9)

f(553774558711019983333.9)

2.8.1.3 Question 20

We wish to create a flight of stairs with \(n\) treads, covering a height \(a\) in meters. Considering that each step has a rise height \(h\) and a tread depth \(d\) that obey to the following proportion: \[2h+d=0.64\]

Define a function that, from a given height to cover and the number of treads, computes the length of the flight of stairs.

2.9 Name Evaluation

The primitive elements presented so far, such as numbers and strings, evaluate to themselves, i.e., the value of an expression composed only by a primitive element is the primitive element itself. For names, this is no longer true.

Names have a special meaning in Julia. Note that when we define a function, we give it a name. Its formal parameters are names as well. When a combination is written, the evaluator uses the function definition associated with the name of the operator of the combination. This means that the value of the operator in a combination is the associated function. If we had defined the function square, as suggested in section Defining Functions, we could verify this behavior by testing the following expressions:

> square(3)

9

> square

square (generic function with 1 method)

As we can see, the value of the name square is an entity that Julia describes using a special notation. This entity is, as shown, a function. The same behavior happens with any other function:

> +

+ (generic function with 178 methods)

> *

* (generic function with 377 methods)

As we have seen, the sum + and multiplication * signs are some of the predefined names of the language. For example, the symbol pi is also predefined and associated with an approximated value of \(\pi\):

> pi

π = 3.1415926535897...

However, when the body of the expression is evaluated, the value of a name assigned to a parameter of the function is the corresponding argument during the function call. For example, in the combination square(3), after figuring out that the value of square is a function and that the value of 3 is \(3\), the evaluator then evaluates the body of the function, replacing the name x, whenever necessary, with the same \(3\) that was previously assigned to the function’s parameter x.

2.10 Conditional Expressions

There are many operations in which the result is dependent on a specific test. For example, the mathematical function \(|x|\), which computes the absolute value of \(x\), is equivalent to the symmetric of \(x\) if \(x\) is negative, and to \(x\) itself otherwise. Using the mathematical notation we have:

\[|x|= \begin{cases} -x, & \text{if $x<0$}\\ x, & \text{otherwise.} \end{cases}\]

This function needs to test if the argument is negative in order to choose one of two alternatives: it either evaluates for the number itself or for its symmetrical value.

Expressions whose result depends on one or more tests are called conditional expressions.

2.10.1 Logical Expressions

A conditional expression follows the structure “if expression then ..., otherwise ...”. The expression that determines whether to use the branch “if” or the branch “otherwise”, is called a logical expression and is characterized for having its value interpreted as either true or false. For example, the logical expression x < 0 tests if the value of x is less than zero; if it is, the expression’s evaluation will return true, otherwise it will return false.

2.10.2 Logical Values

2.11 Predicates

In the most usual case, a logical expression is the application of a function to a set of arguments. In this case, the function is known as a predicate: a function that produces only true or false.

2.11.1 Arithmetic Predicates

The mathematical relational operators \(<\),\(>\),\(=\),\(\leq\) and \(\geq\) are some of the most simple predicates. These operators compare numbers. Their use in Julia follows infix notation and are written respectively <,>,==, <= and >=. Some examples are:

> 4 > 3

true

> 4 < 3

false

> 2+3 <= 6-1

true

> 2+3 == 6-1

true

Note that arithmetic equality in Julia uses ==. This is to avoid any confusion with function definitions, which use =.

2.12 Predicates with a Variable Number of Arguments

An important property of the arithmetic predicates <,>,==, <= and >= is that they accept any number of arguments. Whenever there is more than one argument, the predicate is applied sequentially to pairs of arguments. This property can be seen in the following examples:

> 1 < 2 < 3

true

> 1 < 2 < 2

false

2.13 Recognizers

Apart from relational operators, there are many other predicates in Julia, like iszero, which tests if a number is zero:

> iszero(1)

false

> iszero(0)

true

Note that the operator iszero is used to recognize a particular element (zero) in a data type (numbers). These types of predicates are known as recognizers.

2.14 Logical Operators

In order to combine logical expressions together, we have the conjunction &&, the disjunction ||, and the negation ! operators. While the conjunction and the disjunction operators take two arguments and are written in infix notation, the negation operator takes just one argument in prefix notation. The value of such combinations is determined by the following rules:

• && evaluates arguments from left to right until one of them is false, in which case it returns false. If none of the arguments are false, the && operator returns true.

• || evaluates arguments from left to right until one of them is true, in which case it returns true. If none of the arguments are true, the || operator returns false.

• ! evaluates to true if the argument is false, and evaluates to false if the argument is true.

2.14.1 Exercises 7

2.14.1.1 Question 21

2.14.2 Exercises 8

2.14.2.1 Question 22

What is a conditional expression? What is a logical expression?

2.14.2.2 Question 23

What is a logical value? Which logic values does Julia provide?

2.14.2.3 Question 24

What is a predicate? Give examples of predicates used in Julia.

2.14.2.4 Question 25

What is a relational operator? Give examples of relational operators used in Julia.

2.14.2.5 Question 26

What is a logical operator? Give examples of logical operators used in Julia.

2.14.2.6 Question 27

What is a recognizer? Give examples of recognizers in Julia.

2.14.2.7 Question 28

2.15 Selection

If we look at the mathematical definition of the absolute value function:

\[|x|= \begin{cases} -x, & \text{if $x<0$}\\ x, & \text{otherwise} \end{cases}\]

we notice that it uses a conditional expression in the form of

\[\begin{cases} \mathit{consequent}, & \text{if} \quad\mathit{condition}\\ \mathit{alternative}, & \text{otherwise} \end{cases}\]

that translates to common language as “if condition then consequent, otherwise alternative”.

The evaluation of a conditional expression is done through the evaluation of the condition. If the condition is true, the consequent is evaluated, and if it is false the alternative is evaluated.

Just like Mathematics, Julia supports conditional expressions. To that end, it provides two different forms. We will start with the simplest one, called the ternary operator, whose syntax is the following:

The value of a conditional expression is computed in the following way:

1. The condition is evaluated;

2. If the previous evaluation is true, the value of the conditional expression is the value of the consequent;

3. Otherwise (i.e., if the condition turns out to be false), the value of the conditional expression is the value of the alternative.

This behavior can be verified by the following examples:

> 3 > 2 ? 1 : 2

1

> 3 > 4 ? 1 : 2

2

Using a conditional expression, we can now define the absolute value function by translating its mathematical definition to Julia:

abs(x) = x < 0 ? -x : x

The purpose of the conditional expression is to define functions whose behavior depends on one or more conditions. For example, consider the max function that takes two numbers as arguments and returns the largest. To define such a function we only need to test if the first number is bigger than the second. If it is, the function returns the first argument, otherwise it returns the second one. Based on this logic, we can write:

max(x, y) = x > y ? x : y

The other form of Julia’s conditional expressions uses the words if, else and end, according to the following syntax:

Therefore, the max function can be alternatively written as:

max(x, y) =   if x > y     x   else     y   end

Another far more interesting example is the mathematical function \(\operatorname{sgn}\), also known as signum (Latin for “sign”). This function could be interpreted as the dual function of the absolute value function, since \(x=\operatorname{sgn}(x) |x|\). The sgn function is defined as:

\[\operatorname{sgn} x = \begin{cases} -1 & \text{if $x<0$} \\ 0 & \text{if $x = 0$} \\ 1 & \text{otherwise}\end{cases}\]

In natural language, we would say that if \(x\) is negative, the \(\operatorname{sgn} x\) value is \(-1\), otherwise, if \(x\) is \(0\), the value is \(0\), otherwise the value is \(1\). This shows that the above expression uses two conditional expressions stacked in the following way:

\[\operatorname{sgn} x = \begin{cases} -1 & \text{if $x<0$} \\ \begin{cases} 0 & \text{if $x = 0$} \\ 1 & \text{otherwise}\end{cases} & \text{otherwise}\end{cases}\]

To define this function in Julia, two conditional expressions must be used:

sgn(x) = x < 0 ? -1 : (x == 0 ? 0 : 1)

2.15.1 Multiple Selection

When we begin stacking multiple conditional expressions, the program becomes increasingly harder to read. In this case, there is an alternative syntax that might make the function’s definition easier to read. The syntax is as follows:

The previous form takes as many pairs conditioni–consequenti as needed. Each of these pairs is called a clause. The semantics of a multiple conditional expression is based on the sequential evaluation of the "condition" in each clause until one of them returns true. In that case, the corresponding "consequent" expression is evaluated and the resulting value is returned. If none of the conditions are true, the value of the alternative is returned.

Using the if form makes the sgn function slightly easier to understand:

sgn(x) =   if x < 0     -1   elseif x == 0     0   else     1   end

2.15.2 Exercises 9

2.15.2.1 Question 29

Define the function sum_largest that, given three numbers as arguments, calculates the sum of the two highest values.

2.15.2.2 Question 30

Define the function max3 that, given three numbers as arguments, returns the maximum value.

2.15.2.3 Question 31

Define the function second_largest that, given three numbers as arguments, returns the second highest number, i.e., the number between the maximum and minimum values.

2.16 Local Variables

Consider the following triangle:

\[A=\sqrt{s\left(s-a\right)\left(s-b\right)\left(s-c\right)}\]

in which \(s\) is the triangle’s semi-perimeter:

\[s=\frac{a+b+c}{2}\]

When trying to translate Heron’s formula to Julia we come across a problem: the formula is (also) written in terms of the semi-perimeter \(s\), which is not a parameter but rather a value that is derived from other parameters of the triangle.

One way of solving this problem is to replace \(s\) with its meaning:

\[A=\sqrt{\frac{a+b+c}{2}\left(\frac{a+b+c}{2}-a\right)\left(\frac{a+b+c}{2}-b\right)\left(\frac{a+b+c}{2}-c\right)}\]

From this formula, it is now possible to define the function in Julia:

triangle_area(a, b, c) =   sqrt((a+b+c)/2*((a+b+c)/2-a)*((a+b+c)/2-b)*((a+b+c)/2-c))

Unfortunately, this definition has two problems. The first one is the loss of correspondence between the original formula and the function definition, making it harder to recognize it as Heron’s formula. The second problem is the fact that the function is repeatedly using (a+b+c)/2, which is not only a waste of human effort, because we had to write it four times, but also a waste of computational effort, because, for each invocation of the function, the expression needs to be calculated four times, even though we know it always has the same value.

In order to solve these problems, Julia allows the use of local variables. The meaning of a local variable is restricted to the scope where the variable was established and is used to calculate intermediate values such as the semi-perimeter s. We can create local variables using the let form. The redefinition of the previous function using the let form is as follows:

triangle_area(a, b, c) =   let s = (a+b+c)/2     sqrt(s*(s-a)*(s-b)*(s-c))   end

When we call the function triangle_area, giving it the arguments for the corresponding parameters a, b and c, the function starts by introducing an additional name - s - associated to the value of the expression (a+b+c)/2. The function then evaluates the remaining expressions in the function’s body, which may reference this new name. In practice, it is as if the function was stating: “Knowing that \(s=\frac{a+b+c}{2}\), let us calculate \(\sqrt{s\left(s-a\right)\left(s-b\right)\left(s-c\right)}\).”

In the previous function, we only introduced one local variable, but it is possible to introduce several variables at the same time. The syntax of let is the following:

The semantics of the let form consists in successively associating each name namei to the corresponding expression expri and, in the context established by that association, evaluating the let’s body.

2.17 Global Variables

Contrary to local names that have a limited scope, a global variable is a name that can be seen anywhere in the program. Its context is, therefore, the entire program. The name pi represents the constant \(\pi=3.14159...\) and can be used in any part of our program. For that reason, pi is a global variable.

\[\phi=\frac{1+\sqrt{5}}{2}\approx 1.6180339887\]

We simply need to write:

golden_ratio = (1+sqrt(5))/2

From this moment on, the golden ratio can be referenced in any part of our program.

It is important to note that global variables should be mostly used to define constants.

2.18 Modules

Every functionality of Julia is stored and organized in modules. Every module is a unit containing a set of definitions. The Julia language is nothing more than an aggregation of modules that provide functionalities that are frequently needed. In addition to these, there are many other modules that we can only use if we specifically ask for them.

For example, Julia’s functionality for handling dates is not immediately available. This is visible in the following interaction

> today()

ERROR: UndefVarError: today not defined

> using Dates

> today()

2018-10-07

Note that the first time we tried to use the function today, we got an error saying that the function was not defined. It was only after informing Julia that we needed the functionality provided by the module Dates (employing the using operation) that the function today became available.

2.18.1 Exercises 10

2.18.1.1 Question 32

Check Julia’s documentation and define a module called hyperbolic with the three following functions: hyperbolic sin (sinh), hyperbolic cosin (cosh) and hyperbolic tangent (tanh), based on the mathematical definitions: \[\sinh x = \frac{e^x-e^{-x}}{2}\] \[\cosh x = \frac{e^x+e^{-x}}{2}\] \[\tanh x = \frac{e^x-e^{-x}}{e^x+e^{-x}}\]

2.18.1.2 Question 33

In the same module, define the inverse hyperbolic functions: asinh, acosh, and atanh, whose mathematical definitions are:

\[\sinh^{-1} x=\ln(x+\sqrt{x^2+1})\] \[\cosh^{-1} x=\pm\ln(x+\sqrt{x^2-1})\] \[\tanh^{-1} x=\begin{cases} \frac{1}{2}\ln(\frac{1+x}{1-x}), & \text{if $|x|<1$}\\ \frac{1}{2}\ln(\frac{x+1}{x-1}), & \text{if $|x|>1$} \end{cases}\]

2.18.1.3 Question 34

Set the defined names, from the previous exercises, as available for other modules. Hint: see Julia’s documentation on export.

3 Modeling

We saw in previous sections some types of predefined data in Julia. Frequently, these are enough to build our programs. However, in some cases, it will become necessary to introduce new types of data. In this section, we will address a new type of data that will become particularly useful to model geometric entities: coordinates.

3.1 Coordinates

Cartesian coordinates of a point in space.

There is a large number of useful operations that we can make using coordinates. For example, we can calculate the distance between two positions in space: \(P=(p_x,p_y,p_z)\) and \(Q=(q_x,q_y,q_z)\). That distance can be determined using the formula:

\[d = \sqrt{(q_x-p_x)^2+(q_y-p_y)^2+(q_z-p_z)^2}\]

A possible translation of this definition into Julia’s notation would be:

dist(px, py, pz, qx, qy, qz) = sqrt((qx-px)^2+(qy-py)^2+(qz-pz)^2)

The distance between \((2,1,3)\) and \((5,6,4)\) would then be:

> dist(2, 1, 3, 5, 6, 4)

5.916079783099616

Unfortunately, by treating coordinates as three independent numbers, its use becomes unclear. This can be observed in the function dist, which requires six different parameters, making it hard for the reader to know where the coordinates of each position start and end. This problem becomes even worse when a function must return a position in space, as it happens, for example, with the function that computes the mid position \(M\) between \(P=(p_x,p_y,p_z)\) and \(Q=(q_x,q_y,q_z)\). That position can be calculated using the formula:

\[M = (\frac{p_x+q_x}{2},\frac{p_y+q_y}{2},\frac{p_z+q_z}{2})\]

However, it is difficult to conceive a function that implements this behavior because, apparently, it would have to calculate three different results simultaneously, one for each of the coordinates \(x\), \(y\) and \(z\).

To deal with this kind of problems, mathematicians came up with the concept of \(tuple\). Informally, a tuple is nothing more than a group of values. A position in space is a tuple that groups three coordinates.

Most programming languages have mechanisms to create and manipulate tuples, and Julia is no exception. Julia provides a native tuple type and dedicated syntax to simplify the creation of tuples. For our purposes, however, it is preferable to use a specific kind of tuple to express the coordinate system being used. To use it, we must first require the module Khepri:

To specify the (Cartesian) coordinates \((x,y,z)\), Khepri provides the function xyz:

> xyz(1, 2, 3)

xyz(1,2,3)

> xyz(2*3, 4+1, 6-2)

xyz(6,5,4)

Note that the result of evaluating the expression xyz(1, 2, 3) is a value that represents a position in the three-dimensional Cartesian space. The value belongs to a type of information that is different from the ones previously seen, such as numbers and strings, and is written by Julia using the same syntax used to create it.

3.2 Operations with Coordinates

Now that we know how to create coordinates, we can rethink the functions that manipulate them. Let us begin with the function that calculates the distance between two positions \(P=(p_x,p_y,p_z)\) and \(Q=(q_x,q_y,q_z)\), which, as we saw, can be calculated using the formula:

\[\sqrt{(q_x-p_x)^2+(q_y-p_y)^2+(q_z-p_z)^2}\]

A first draft of this definition translated into Julia would be:

dist(p, q) =

sqrt((qx?-px?)^2+(qy?-py?)^2+(qz?-pz?)^2)

In order to complete the function, we need to know how to get the \(x\), \(y\), and \(z\) coordinates of a given position \(P\). For that purpose, Khepri provides the functions cx, cy and cz, abbreviations for coordinate x, coordinate y and coordinate z, respectively.

The functions xyz, cx, cy and cz can be considered the fundamental operations on coordinates. The first one allows us to construct a position given three numbers, and the others allow us to know which numbers determine a given position. For this reason, the first operation is said to be a constructor of coordinates, whereas the others are selectors of coordinates.

Although we are unaware of how these functions operate internally, we know they are consistent with each other, ensured by the following expressions:

cx(xyz(x, y, z)) \(=\) x

cy(xyz(x, y, z)) \(=\) y

cz(xyz(x, y, z)) \(=\) z

Using these functions we can now write:

dist(p, q) = sqrt((cx(q)-cx(p))^2+(cy(q)-cy(p))^2+(cz(q)-cz(p))^2)

> dist(xyz(2, 1, 3), xyz(5, 6, 4))

5.916079783099616

To simplify the use of the functions cx, cy and cz, Khepri allows an additional syntax that is closer to Mathematics. Using this syntax, the expressions cx(p), cy(p), and cz(p) can be written, respectively, as p.x, p.y, and p.z. This allows us to simplify the previous function definition:

dist(p, q) = sqrt((q.x-p.x)^2+(q.y-p.y)^2+(q.z-p.z)^2)

Let us look at another example. Suppose we want to define a function, named add_xyz, which calculates the position of a point after a translation, expressed in terms of its orthogonal components \(\Delta_x\), \(\Delta_y\) and \(\Delta_z\), as can be seen in this figure, on the left. For \(P=(x,y,z)\) we will have \(P'=(x+\Delta_x,y+\Delta_y,z+\Delta_z)\). Naturally, the function needs as inputs a starting point \(P\) and the increments \(\Delta_x\), \(\Delta_y\) and \(\Delta_z\), which we will name as dx, dy, and dz, respectively.

The definition of this function is as follows:

add_xyz(p, dx, dy, dz) = xyz(p.x+dx, p.y+dy, p.z+dz)

However, just like it happened previously, it is not very practical to separately specify each of the components of the translation. Fortunately, we can avoid this problem by using a vector. A vector is a mathematical entity that includes a direction and a magnitude, and thus can easily represent a translation. Note that a vector has neither an origin nor a destination.

In this figure, on the right, the vector \(V=(\Delta_x, \Delta_y, \Delta_z)\) represents the displacement that we want to apply to the position \(P\) to reach the position \(P'\). If we define the addition \(P+V\) of the position \(P=(x,y,z)\) with the vector \(V=(\Delta_x, \Delta_y, \Delta_z)\) as \((x+\Delta_x,y+\Delta_y,z+\Delta_z)\), it becomes evident that \(P'=P+V\). In the same way, it is possible to define the vector \(V\) as the difference between the two positions, i.e., \(V=P'-P\). Many other operations are meaningful in the context of vectors, including addition and subtraction of vectors, as well as product of vectors by scalars or by other vectors. This vector algebra, known since the 17th century, allows the simplification of computations involving positions and displacements.

The point \(P'\) as a result of the translation of the point \(P=(x,y,z)\) by adding \(\Delta_x\) in the \(X\) axis, \(\Delta_y\) in the \(Y\) axis and \(\Delta_z\) in the \(Z\) axis.

Given the usefulness of vectors, these are also provided by Khepri under the form of an operation called vxyz, which, from three independent displacements along the coordinate axes \(X\), \(Y\), and \(Z\), produces the corresponding vector. Similarly to positions, vectors can be used with the operations cx, cy, and cz, and with the alternative syntax .x, .y, and .z.

The following interaction demonstrates the use of positions and vectors:

> xyz(1,2,3) + vxyz(3,2,1)

xyz(4.0,4.0,4.0)

> xyz(4,5,6) - xyz(3,2,1)

vxyz(1.0,3.0,5.0)

> vxyz(4,5,6) - vxyz(3,2,1)

vxyz(1.0,3.0,5.0)

> xyz(1,2,3) + (xyz(4,5,6) - xyz(3,2,1))

xyz(2.0,5.0,8.0)

> xyz(1,2,3) + xyz(4,5,6) - xyz(3,2,1)

ERROR: MethodError: no method matching +(::XYZ, ::XYZ)

> xyz(1,2,3) - xyz(3,2,1) + xyz(4,5,6)

xyz(2.0,5.0,8.0)

> vxyz(1,2,3) + vxyz(4,5,6) - xyz(3,2,1)

ERROR: MethodError: no method matching -(::VXYZ, ::XYZ)

Note that not all operations are possible. In particular, the addition of positions does not make sense.

3.2.1 Exercises 11

3.2.1.1 Question 35

Define the function midpoint that calculates the location of the midpoint between two points \(P_0\) and \(P_1\).

3.2.1.2 Question 36

Define the function equal_c that takes two points and returns true if they are coincident. Note that two points are coincident when their \(x\), \(y\), and \(z\) coordinates are equal.

3.2.2 Bi-dimensional Coordinates

Just as three-dimensional coordinates locate points in space, bi-dimensional coordinates locate points in a plane. The question to be asked is: which plane? From a mathematical point of view, this question is not relevant since it is perfectly possible to think about geometry in a plane without needing to visualize the plane itself. But when we try to visualize that geometry in a 3D modeling program, we must inevitably think where that plane is located. If omitted, CAD applications will consider, by default, the bi-dimensional plane as the \(XY\) plane, being the height \(z\) equal to zero. So let us consider the bi-dimensional coordinates \((x,y)\) as a simplified notation for the three-dimensional coordinates \((x,y,0)\).

Based on this simplification, we can define a bi-dimensional coordinates’ constructor in terms of the three-dimensional coordinates’ constructor:

xy(x, y) =

xyz(x, y, 0)

In the same way, we can define constructors for bi-dimensional coordinates along the other coordinate planes, i.e., \(XZ\) and \(YZ\):

xz(x, z) =

xyz(x, 0, z)

yz(y, z) =

xyz(0, y, z)

Similarly, we can define bi-dimensional vectors using the same approach:

vxy(dx, dy) =

vxyz(dx, dy, 0)

vxz(dx, dz) =

vxyz(dx, 0, dz)

vyz(dy, dz) =

vxyz(0, dy, dz)

One advantage of the definition of bi-dimensional positions and vectors on top of three-dimensional ones is the fact that the coordinate selectors become immediately applicable to bi-dimensional coordinates and, therefore, all other operations defined using the selectors are also applicable to the bi-dimensional case.

3.2.3 Exercises 12

3.2.3.1 Question 37

Given the point \(P_0=(x_0,y_0)\) and a line defined by two points \(P_1=(x_1,y_1)\) and \(P_2=(x_2,y_2)\), the minimum distance \(d\) between \(P_0\) and the line is given by:

\[d=\frac{\left\vert(x_2-x_1)(y_1-y_0)-(x_1-x_0)(y_2-y_1)\right\vert}{\sqrt{(x_2-x_1)^2+(y_2-y_1)^2}}\]

Define a function point_line_distance that, given the coordinates of \(P_0\), \(P_1\) and \(P_2\), returns the minimum distance between \(P_0\) and the line defined by \(P_1\) and \(P_2\).

3.2.3.2 Question 38

3.2.4 Polar Coordinates

Although the Cartesian coordinate system is widely used, there are other coordinate systems that can be more useful in certain situations. As an example, suppose we wanted to place \(n\) elements equally spaced between them and with the distance \(d\) from the origin point, as is represented in this figure. Logically, the elements will form a circle and the angle between them is \(\frac{2\pi}{n}\).

Positions along a circle.

Taking the \(X\) axis as a reference, we can say that the first element will be positioned at a distance \(d\) from the origin point, the second element will have the same distance but on a different axis that makes a \(\frac{2\pi}{n}\) angle with the \(X\) axis, the third element will also have the same distance but is positioned in an axis that makes an angle of \(\frac{4\pi}{n}\) with the \(X\) axis, and so on. However, when trying to define those positions using Cartesian coordinates, we would find that the regularity expressed with the “and so on” is immediately lost. This should make us consider a different system of coordinates, namely, the polar coordinate system.

As represented in this figure, a position in a bi-dimensional plane is expressed, in rectangular coordinates, by the numbers \(x\) and \(y\) - respectively the abscissa (x coordinate) and ordinate (y coordinate), while in polar coordinates it is expressed by \(\rho\) and \(\phi\) - respectively the radius vector (also called modulus) and the polar angle (also called argument). With the help of trigonometry and the Pythagorean theorem it is easy to convert polar coordinates into rectangular coordinates:

\[\left\{\begin{aligned} x&=\rho \cos \phi\\ y&=\rho \sin \phi \end{aligned}\right.\]

Likewise, it is also straightforward to convert rectangular coordinates into polar coordinates:

\[\left\{\begin{aligned} \rho&=\sqrt{x^2 + y^2}\\ \phi&=\arctan \frac{y}{x} \end{aligned}\right.\]

Rectangular and polar coordinates.

Based on the above equations, we can define the constructor of polar coordinates pol (abbreviation of polar) by simply converting them into the equivalent rectangular representation:

pol(rho, phi) = xy(rho*cos(phi), rho*sin(phi))

pol_rho(c) = sqrt(c.x^2+c.y^2)

pol_phi(c) = atan(c.y, c.x)

> pol(1, 0)

xyz(1.0,0.0,0)

> pol(sqrt(2), pi/4)

xyz(1.0000000000000002,1.0,0)

> pol(1, pi/2)

xyz(6.123233995736766e-17,1.0,0)

> pol(1, pi)

xyz(-1.0,1.2246467991473532e-16,0)

In case we want to specify vectors in polar coordinates, as illustrated in this figure, we can use a similar approach, by defining the constructor vpol:

vpol(rho, phi) = vxy(rho*cos(phi), rho*sin(phi))

A point displacement in polar coordinates.

Consider the following examples of usage:

> xy(1, 2)+vpol(sqrt(2), pi/4)

xyz(2.0,3.0,0.0)

> xy(1, 2)+vpol(1, 0)

xyz(2.0,2.0,0.0)

> xy(1, 2)+vpol(1, pi/2)

xyz(1.0,3.0,0.0)

3.2.5 Exercises 13

3.2.5.1 Question 39

The function equal_c defined in Question 36 compares the coordinates of two points, returning true if they are coincident. However, taking into account that numeric operations can produce rounding errors, it is possible that two coordinates, which in theory should be the same, in practice are not considered as such. For example, the point \((-1,0)\) in rectangular coordinates can be expressed in polar coordinates as \(\rho=1, \phi=\pi\) but Julia will not consider them equal, as can be seen in the example below:

> equal_c(xy(-1, 0), pol(1, pi))

false

> xy(-1, 0)

xyz(-1,0,0)

> pol(1, pi)

xyz(-1.0,1.2246467991473532e-16,0)

As you can see, although the coordinates are not the same, they are very close, i.e., the distance between them is very close to zero. Propose a new definition for the function equal_c based on the concept of distance between coordinates.

3.3 Bi-dimensional Drawing

In this section we will introduce some bi-dimensional drawing operations.

In order to visualize the shapes that we will create, we need to have a CAD application, like AutoCAD or Rhinoceros (commonly abbreviated to Rhino). The choice of which CAD application we wish to use is made by employing the backend function together with the argument autocad or rhino. Therefore, a program that uses Khepri usually starts with:

using Khepri

backend(autocad)

or with:

using Khepri

backend(rhino)

depending on the user’s preference for AutoCAD or Rhino, respectively.

using Khepri

backend(autocad)

circle(pol(0, 0), 4)

circle(pol(4, pi/4), 2)

circle(pol(6, pi/4), 1)

A series of circles.

line(xy(-1, -1), xy(-1, 0), xy(1, 0), xy(1, 1))

line(xy(-1, 1), xy(0, 1), xy(0, -1), xy(1, -1))

A set of line segments.

In case we wish to draw closed polygonal lines, it is preferable that we use the polygon function, which is very similar to the function line but with the difference that it creates an additional segment connecting the last position with the first. This figure shows the result of the following expression:

polygon(pol(1, 2*pi*0/5),

pol(1, 2*pi*1/5),

pol(1, 2*pi*2/5),

pol(1, 2*pi*3/5),

pol(1, 2*pi*4/5))

For drawing regular polygons, i.e., polygons that have equal edges and angles, as the one shown in this figure, it is preferable to use the function regular_polygon. This function receives as arguments the number of sides, the center position, a radius, a rotation angle, and a boolean to indicate if the radius refers to an inscribed circle (i.e. the radius is the distance from the edges’ midpoints to the center) or a circumscribed circle (i.e. the radius is the distance from the vertices to the center). If omitted, the center point will be considered the origin, the radius will have one unit of measurement, the angle will be considered zero and the circle will be circumscribed.

Using the regular_polygon function, this figure can be obtained by:

regular_polygon(5)

A polygon.

More interesting examples can be obtained by different rotation angles. For example, the following expressions will produce the image shown in this figure:

Overlapping triangles, squares and pentagons with different rotation angles.

For four-sided polygons aligned with the \(X\) and \(Y\) axes, there is a very simple function: rectangle. This function can either be used with the position of its bottom left corner and top right corner or with the position of its bottom left corner and the rectangle dimensions, as exemplified below and represented in this figure:

rectangle(xy(0, 1), xy(3, 2))

rectangle(xy(3, 2), 1, 2)

A set of rectangles.

In the following sections we will introduce the remaining modeling functions available in Khepri.

3.3.1 Exercises 14

3.3.1.1 Question 40

Recreate the drawing presented in this figure but, this time, using rectangular coordinates.

3.3.1.2 Question 41

We wish to place two circles with unit radius around an origin so that the circles are tangent to each other as shown in the following drawing:

Write a sequence of expressions that produce the above image.

3.3.1.3 Question 42

We wish to place four circles with unit radius around an origin so that the circles are tangent to each other as shown in the following drawing:

Write a sequence of expressions that produce the above image.

3.3.1.4 Question 43

We wish to place three circles with unit radius around an origin so that the circles are tangent to each other as shown in the following drawing:

Write a sequence of expressions that produce the above image.

3.4 Side Effects

In Julia, as we have previously seen, every expression has a value. That is visible when evaluating an arithmetic expression but also when evaluating a geometric expression:

> 1+2

3

> circle(xy(1, 2), 3)

Circle(...)

In the last example, the result of evaluating the second expression is a geometric entity. When Julia writes a result that is a geometric entity it uses a notation based on the name of that entity. Most of the times, we are not interested in seeing a geometric entity as a piece of text but, instead, in visualizing that entity in space. For that purpose, the evaluation of geometric expressions also has a side effect: all created geometric shapes are automatically added to a chosen CAD application using the backend function.

That way, evaluating the following program:

using Khepri

backend(autocad)

circle(xy(1, 2), 3)

produces as a result an abstract value representing a circle centered at the point \(1,2\) and with a radius of \(3\) units and, as a side effect, that circle becomes visible in AutoCAD.

This behavior of geometric functions, like circle, line, rectangle, etc., is fundamentally different from the ones we have seen so far. Previously, functions were used to compute something, i.e., to produce a value, whereas now it is not the value that interests us the most but, rather, the side effect (also called collateral effect) that allows us to visualize the geometric shape in the CAD application.

One important aspect of using side effects is the possibility of their composition. The composition of side effects is accomplished through sequencing, i.e., the sequential computation of the different effects. In the next section we will discuss sequencing of side effects.

3.5 Sequencing

So far, we have combined mathematical expressions using mathematical operators. For example, from the expressions sin(x) and cos(x), we can calculate their division using sin(x)/cos(x). This is possible because the evaluation of the sub-expressions sin(x) and cos(x) will produce two values that can then be used in the division.

With geometric functions, instead of combinations of values, we are mostly interested in combinations of side effects. To this end, Julia provides a way of producing them sequentially, i.e., one after the other. For example, consider a function that draws a circle with a radius \(r\), centered on the position \(P\), with an inscribed or circumscribed square, depending on the user’s specification, as we show in this figure.

A circle with an inscribed square (left) and a circumscribed square (right).

The function’s definition could start as something like:

circle_square(p, r, inscribed) =

...

The drawing produced by the function will naturally depend on the logic value of inscribed, which means that this function’s definition could be something like:

circle_square(p, r, inscribed) =

inscribed ?

creates a circle and a square inscribed in the circle :

creates a circle and a square circumscribed in the circle

The problem now is that, for each case of the conditional expression, the function must generate two side effects, namely, to create a circle and to create a square. However, the conditional expression only admits one expression, making us wonder how we can combine two side effects in a single expression. For this purpose, Julia provides the concept of compound expression. Any sequence of expressions can be transformed into a compound expression by separating them with semicolons and wrapping the result in parentheses, for example:

> 1+(2*3; 4*5)

21

A compound expression can take any number of expressions, and its evaluation will sequentially evaluate each of them, i.e., one after the other, returning the value of the last one (as is visible in the previous example). Logically, if only the value of the last expression is used, then the values of the other expressions are discarded and these expressions are only relevant for their side effects.

In order to make compound expressions more visible, Julia also supports a different syntax based on the use of the words begin/end. In this case, it is also possible to avoid the semicolon by placing different expressions in different lines. For example:

1 + begin 2*3; 4*5 end

1 + begin

2*3

4*5

end

Using compound expressions, we can further detail our circle_square function using either

circle_square(p, r, inscribed) =

inscribed ?

(creates a circle;

creates a square inscribed in the circle) :

(creates a circle;

creates a square circumscribed in the circle)

or

circle_square(p, r, inscribed) =

inscribed ?

begin

creates a circle

creates a square inscribed in the circle

end :

begin

creates a circle

creates a square circumscribed in the circle

end

Interestingly, the if form described in section Multiple Selection also allows further simplification, as it includes an implicit begin/end on each clause, meaning that the previous function can be written as:

circle_square(p, r, inscribed) =

if inscribed

creates a circle

creates a square inscribed in the circle

else

creates a circle

creates a square circumscribed in the circle

end

All we need to do now is translate the remaining sentences into the corresponding Julia expressions. In the case of the inscribed square, we will use polar coordinates because we know its vertices will be set in a circle (the top right vertex at an angle of \(\frac{\pi}{4}\) and the bottom left vertex at an angle of \(\pi+\frac{\pi}{4}\)).

circle_square(p, r, inscribed) =

if inscribed

circle(p, r)

rectangle(p + vpol(r, 5/4*pi), p + vpol(r, 1/4*pi))

else

circle(p, r)

rectangle(p - vxy(r, r), p + vxy(r, r))

end

An attentive look at the previous function circle_square shows that a circle is always created independently of the square being inscribed or not. That way we can redefine the function so that the circle is created outside the conditional expression:

circle_square(p, r, inscribed) =

begin

circle(p, r)

if inscribed

rectangle(p + vpol(r, 5/4*pi), p + vpol(r, 1/4*pi))

else

rectangle(p - vxy(r, r), p + vxy(r, r))

end

end

Julia allows a final simplification based on the use of an alternative syntax for function definitions: instead of

we can use

Using this last syntax, we have:

function circle_square(p, r, inscribed)

circle(p, r)

if inscribed

rectangle(p + vpol(r, 5/4*pi), p + vpol(r, 1/4*pi))

else

rectangle(p - vxy(r, r), p + vxy(r, r))

end

end

To sum up, Julia provides two different but equivalent syntaxes for function definitions, for conditional expressions, and for compound expressions. We should use the one that, for each particular case, makes the program easier to understand.

3.6 Doric Order

The Doric order, exemplified in the Greek Temple of Segesta, which was never finished. Photograph by Enzo De Martino.

For simplification purposes, we are going to start by sketching a Doric column (without flutes) in two dimensions. In the following sections, we will extend this process to create a three-dimensional model.

The same way a Doric column can be decomposed into its basic components - shaft, echinus and abacus - its corresponding drawing can too be decomposed in components. Therefore, we will create separate functions to draw the shaft, the echinus, and the abacus. This figure shows a reference model.

The Doric column for reference.

Let us start by defining a function for the shaft:

shaft() = line(xy(-0.8, 10), xy(-1, 0), xy(1, 0), xy(0.8, 10), xy(-0.8, 10))

In this example, we used the line function that, given a sequence of positions, creates a line with vertices on those positions. Another possibility, probably more appropriate, would be to create a closed polygonal line, something we can do with the polygon function, avoiding the repeated position, i.e.:

shaft() = polygon(xy(-0.8, 10), xy(-1, 0), xy(1, 0), xy(0.8, 10))

To complete the figure, we also need a function for the echinus and another for the abacus. The reasoning for the echinus is similar:

echinus() = polygon(xy(-0.8, 10), xy(-1, 10.5), xy(1, 10.5), xy(0.8, 10))

For the abacus, we could follow a similar strategy or, alternatively, we could employ the function that creates rectangles. This function requires two positions to define a rectangle:

abacus() = rectangle(xy(-1, 10.5), xy(1, 11))

Finally, we have the function that creates a Doric column, which sequentially calls the shaft, echinus and abacus functions:

doric_column() = begin   shaft()   echinus()   abacus() end

This figure shows the result of invoking the doric_column function.

A Doric column.

3.7 Parametrization of Geometric Figures

Unfortunately, the Doric column we created has a fixed location and a fixed size, making it difficult to use this function in different contexts. Naturally, this function would be much more useful if it was parametrized, i.e., if the creation of the column depended on the parameters that characterize it, as for example, the column’s base coordinates, the height of the echinus, shaft, and abacus, the base and top echinus radius, etc.

In order to better understand the parametrization of these functions, let us start by considering the shaft represented in this figure.

Sketch of a column’s shaft.

The first step in parametrizing a geometrical drawing is to correctly identify the relevant parameters. In the case of the shaft, one of the obvious parameters would be its spatial location. Let us then consider that the shaft will have its base’s center point placed at an imaginary point \(P\) of coordinates \((x,y)\). In addition to this parameter, we also need know the height of the shaft \(h\), the base radius \(r_b\) and the top radius \(r_t\).

To make the drawing process easier, it is convenient to consider additional reference points in our sketch. For the shaft, since it is shaped essentially like a trapezoid, we can look at its representation as a succession of line segments along the points \(P_1\), \(P_2\), \(P_3\) and \(P_4\), whose coordinates we can easily calculate from \(P\).

We now have all we need to define a function that draws the column’s shaft. To make the program clearer, we will use the names h_shaft for the height \(h\), r_base for the base radius, and r_top for the top radius. The parametrized definition will be:

shaft(p, h_shaft, r_base, r_top) =   polygon(p+vxy(-r_top, h_shaft),           p+vxy(-r_base, 0),           p+vxy(+r_base, 0),           p+vxy(+r_top, h_shaft))

Next, we need to draw the echinus. It is convenient to consider, once more, a geometrical sketch, as shown in this figure.

Sketch of an echinus.

Similarly to the shaft, considering the base’s center point \(P\), we can compute the coordinates that define the vertices of the echinus representation. Using those points, the function will be:

echinus(p, h_echinus, r_base, r_top) =   polygon(p+vxy(-r_base, 0),           p+vxy(-r_top, h_echinus),           p+vxy(+r_top, h_echinus),           p+vxy(+r_base, 0))

Having done the shaft and echinus, all that is left now is to draw the abacus. For that, we can consider another geometric sketch, as shown in this figure.

Sketch of an abacus.

Once more, we will consider \(P\) as the starting point in the center of the abacus’ base. From this point, we can easily calculate the points \(P_1\) and \(P_2\), which are the two opposite corners of the rectangle that represents the abacus. That way, we have:

abacus(p, h_abacus, l_abacus) =   rectangle(p+vxy(-(l_abacus/2), 0), p+vxy(l_abacus/2, h_abacus))

Finally, to create the entire column, we must combine the functions that draw the shaft, the echinus and the abacus. However, we need to take into account that, as this figure shows, the shaft’s top radius is coincident with the echinus’ base radius, and the echinus top radius is half the length of the abacus. The figure also shows that the coordinates of the echinus’ base result from adding the shaft’s height to the coordinates of the shaft’s base, and that those of the abacus’s base result from adding the combined heights of the shaft and echinus to the shaft’s base coordinates.

Composition of the shaft, echinus and abacus.

As we did before, let us give more appropriate names to the parameters in this figure. Using the names p, h_shaft, r_base_shaft, h_echinus, r_base_echinus, h_abacus and l_abacus instead of the corresponding, \(P\), \(h_s\), \(r_{bs}\), \(h_e\), \(r_{be}\), \(h_a\) and \(l_a\), we obtain:

column(p, h_shaft, r_base_shaft, h_echinus, r_base_echinus, h_abacus, l_abacus) =   begin     shaft(p, h_shaft, r_base_shaft, r_base_echinus)     echinus(p+vxy(0, h_shaft), h_echinus, r_base_echinus, l_abacus/2)     abacus(p+vxy(0, h_shaft+h_echinus), h_abacus, l_abacus)   end

Using this function we can easily explore different variations of columns. The following expressions reproduce the examples in this figure.

column(xy(0, 0), 9, 0.5, 0.4, 0.3, 0.3, 1.0)

column(xy(3, 0), 7, 0.5, 0.4, 0.6, 0.6, 1.6)

column(xy(6, 0), 9, 0.7, 0.5, 0.3, 0.2, 1.2)

column(xy(9, 0), 8, 0.4, 0.3, 0.2, 0.3, 1.0)

column(xy(12, 0), 5, 0.5, 0.4, 0.3, 0.1, 1.0)

column(xy(15, 0), 6, 0.8, 0.3, 0.2, 0.4, 1.4)

Multiple Doric columns.

As we can see, not all columns obey the proportion’s canon of the Doric order. In the section Vitruvian Proportions, we are going to see which modifications are needed to avoid this problem.

3.8 Documentation

In the column function, h_shaft is the shaft’s height, r_base_shaft is the shaft’s base radius, h_echinus is the echinus’ height, r_base_echinus is the echinus’s base radius, h_abacus is the abacus’ height and, finally, l_abacus is the abacus’ length. Because the function already employs many parameters and its meaning may not be clear to someone that reads the function’s definition for the first time, it is convenient to document the function. For that, Julia provides two different features. The first one is the character #: each time the character # is used, Julia will ignore everything that is in front of it until the end of the line. That allows text to be written in the code without Julia trying to interpret its meaning. The second one is the concept of documentation string: a string that appears immediately before a function definition is treated as the documentation of that function.

# Drawing Doric Columns

# The drawing of a Doric column is divided into three parts:

# shaft, echinus and abacus. Each of these parts has an

# independent function.

"

Draws the shaft of a Doric column.

p: column's center base coordinate,

h-shaft: shaft's height,

r-base: shaft's base radius,

r-top: shaft's top radius.

"

shaft(p, h_shaft, r_base, r_top) =

polygon(p+vxy(-r_top, h_shaft),

p+vxy(-r_base, 0),

p+vxy(+r_base, 0),

p+vxy(+r_top, h_shaft))

"

Draws the echinus of a Doric column.

p: echinus' center base coordinate,

h-echinus: echinus' height,

r-base: echinus' base radius,

r-top: echinus' top radius.

"

echinus(p, h_echinus, r_base, r_top) =

polygon(p+vxy(-r_base, 0),

p+vxy(-r_top, h_echinus),

p+vxy(+r_top, h_echinus),

p+vxy(+r_base, 0))

"

Draws the abacus of a Doric column.

p: abacus' center base coordinate,

h-abacus: abacus' height,

l-abacus: abacus' length.

"

abacus(p, h_abacus, l_abacus) =

rectangle(p+vxy(-(l_abacus/2), 0), p+vxy(l_abacus/2, h_abacus))

"

Draws a Doric column composed of a shaft, an echinus and an abacus.

p: column's center base coordinate,

h-shaft: shaft's height,

r-base-shaft: shaft's base radius,

h-echinus: echinus' height,

r-base-echinus: echinus' base radius = shaft's top radius,

h-abacus: abacus' height,

l-abacus: abacus' length = 2*echinus top radius.

"

column(p, h_shaft, r_base_shaft, h_echinus, r_base_echinus, h_abacus, l_abacus) =

begin

# We draw the shaft at the base point p

shaft(p, h_shaft, r_base_shaft, r_base_echinus)

# We place the echinus on top of the shaft

echinus(p+vxy(0, h_shaft), h_echinus, r_base_echinus, l_abacus/2)

# and the abacus on top of the echinus

abacus(p+vxy(0, h_shaft+h_echinus), h_abacus, l_abacus)

end

When a program is documented, it is easier to understand what the program does, without having to study the functions’ body. Although it is important to document our programs, it is also important to note that excessive documentation can also have disadvantages. To avoid them, the following ideas should be taken into consideration:

• The code in Julia should be clear enough for a human being to understand. It is better to spend more time writing clearer code than to write documentation explaining it.

• Having documentation that does not correspond to the program is worse than having no documentation at all.

• Frequently, we need to modify our programs in order to adapt them to different purposes. The more documentation we have, the more documentation we will have to modify to make it coherent with the changes made to the program.

For these reasons, we should try to write the code as clear as possible and, at the same time, provide short and useful documentation: the documentation should not say what is already obvious from reading the program.

3.8.1 Exercises 15

3.8.1.1 Question 44

Consider an arrow with an origin in \(P\), a length of \(\rho\), an inclination \(\alpha\), an opening angle \(\beta\) and an arrowhead size \(\sigma\) as shown in the following figure:

Define a function arrow that, given the parameters \(P\), \(\rho\), \(\alpha\), \(\beta\), and \(\sigma\), creates the corresponding arrow.

3.8.1.2 Question 45

Using the function arrow, define a new function called arrow_from_to that, given two points, creates an arrow that goes from the first point to the second. The arrowhead should have a \(\sigma\) size of one unit and an angle \(\beta\) of \(\frac{\pi}{8}\).

3.9 Debugging

As we all know, errare humanum est. Making mistakes is part of our day-to-day life and, in general, we know how to deal with them. Unfortunately, this does not apply to programming languages. Any mistake made in a computer program will result in an unexpected behavior.

Seeing how easy it is to make errors, it should also be easy to detect and correct them. The process of detecting and correcting errors is called debugging. Different programming languages provide different mechanisms to accomplish such process. As we will see, Julia is particularly well equipped in this domain.

Generally, errors in programs can be classified as syntactic errors or semantic errors.

3.9.1 Syntactic Errors

Syntactic errors occur each time we write a line of code that does not follow the language’s grammar rules. As an example, suppose we wish to define a function to create a single Doric column, to which we will refer as standard, which has always the same dimensions, thus dispensing the need for any parameters. One possible definition is:

However, if we test this definition, Julia will produce an error, telling us that something is wrong:

The error Julia is warning us about is that the function definition does not follow the required syntax and, in fact, a careful look at it shows that we made a mistake in the name of the function: instead of standard-column, we should have used standard_column. This mistake makes it impossible for Julia to recognize the program as a proper function definition and, therefore, Julia reports a syntactic error, i.e., it complains that it found a sentence which does not obey the language syntax.

There are several other types of errors that Julia is capable of detecting; some of these will be discussed further ahead. The important thing to remember is not the different kinds of syntactic errors that Julia is capable of detecting but, rather, Julia’s capability to check the expressions we write and detect syntactic errors in them.

3.9.2 Semantic Errors

Semantic errors are very different from syntactic ones. A semantic error is not the misspelling of a sentence but rather a mistake in its meaning. In other terms, a semantic error occurs when we write a sentence which we think has a certain meaning but, in reality, has a different one.

Generally, semantic errors can only be detected during the evaluation of the expressions that contain them. Some semantic errors are detectable by Julia’s evaluator but many of them can only be detected by the programmer.

As an example, consider a meaningless operation such as the sum of a number with a string:

> 1+"two"

ERROR: MethodError: no method matching +(::Int64, ::String)

As we can see, Julia complains that there is no way for it to add an integer (the type Int64) with a string (the type String). In this example, the mistake is obvious enough for us to detect it immediately. However, with more complex programs, the process of finding mistakes can often be slow and frustrating. It is also a fact that, the more experienced we get at detecting and correcting errors, the faster we will be at doing it.

3.10 Three-dimensional Modeling

As we have seen in the section Bi-dimensional Drawing, Khepri provides a set of operations (lines, rectangles, circles, etc.) that allow us to easily draw bi-dimensional representations of objects, such as floor plans, elevations, cross sections, etc.

Although until this moment we have only used Khepri’s bi-dimensional drawing capacities, we now will explore three-dimensional modeling. This type of modeling represents lines, surfaces and solids in the three-dimensional space.

In this section, we will address the Khepri’s functions that allow the creation of such three-dimensional objects.

3.10.1 Predefined Solids

Khepri provides a set of predefined functions that create solids from their three-dimensional coordinates. Although these predefined functions only allow the creation of a limited set of solids, they are enough to create sophisticated models.

The predefined operations can create boxes (function box), cylinders (function cylinder), cones (function cone), spheres (function sphere), tori (function torus), and pyramids (function regular_pyramid), among others. Each of these functions accepts various optional arguments for creating these solids in different ways. This figure shows a set of solids built from the following expressions:

box(xyz(2, 1, 1), xyz(3, 4, 5))

cone(xyz(6, 0, 0), 1, xyz(8, 1, 5))

cone_frustum(xyz(11, 1, 0), 2, xyz(10, 0, 5), 1)

sphere(xyz(8, 4, 5), 2)

cylinder(xyz(8, 7, 0), 1, xyz(6, 8, 7))

regular_pyramid(5, xyz(-2, 1, 0), 1, 0, xyz(2, 7, 7))

torus(xyz(14, 6, 5), 2, 1)

Primitive solids in Khepri.

It is interesting to notice that some of the most important works in architectural history can be roughly modeled using these operations. One example is the Great Pyramid of Giza, pictured in this figure, which was built over forty-five centuries ago and is an almost perfect example of a square pyramid. In its original form, it is believed that the Great Pyramid had a squared base, measuring 230 meters on each side, and with a height of 147 meters (making it the tallest man-made structure up until the construction of the Eiffel Tower). Many other Egyptian pyramids have similar proportions, making them easy to model with the following function:

egyptian_pyramid(p, side, height) =   regular_pyramid(4, p, side/2, 0, height, false)

The case of the Great Pyramid of Giza would be:

egyptian_pyramid(xyz(0, 0, 0), 230, 147)