Geometry in competitive programming

Dissertation presented by
Victor LECOMTE

for obtaining the master's degree in

Computer Science and Engineering

Supervisor
Yves DEVILLE

Co-supervisor
François AUBRY

Readers
François AUBRY, Yves DEVILLE, Jean-François REMACLE

Academic year 2017-2018

 Abstract

Competitive programming consists in the organization of programming con-

tests, which see the world’s most talented coders compete to solve problems
of an algorithmic nature by implementing efficient programs as quickly as
possible. Recently, geometry problems have had an increasing importance
in those contests, but many contestants dislike them for being too technical
or causing too precision issues linked to the use of floating-point numbers.
We believe that those complaints are for the largest part due to a lack
of specific training on the basics of computational geometry. We therefore
introduce a new handbook of computational geometry, aimed primarily at
the competitive programming public. It treats the subject in a practice-
oriented way, providing code snippets for every operation, and explaining
them in intuitive terms with the help of a large amount of illustrative figures.
Its contents focus on the foundations of both 2D and 3D computational
geometry, as well as the management of floating-point imprecisions, where
we present a model of error propagation based on magnitude conditions and
dimensionality of values.
In addition, we present an original geometry contest whose problems
showcase innovative notions and techniques, especially in 3D geometry. We
hope that in the future, problem setters can reuse and adapt those ideas in
order to foster variety and expand the scope of geometry as a competitive
programming subfield.
Contents

I Main contents 6

1 Introduction 7
1.1 About competitive programming . . . . . . . . . . . . . . . . 7
1.2 Types of programming contests . . . . . . . . . . . . . . . . . 8
1.3 Geometry in competitive programming . . . . . . . . . . . . . 9
1.4 Goals and structure of this thesis . . . . . . . . . . . . . . . . 9

2 Writing a handbook of geometry 11

2.1 Approach and writing style . . . . . . . . . . . . . . . . . . . 11
2.2 Current contents . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Publication and future plans . . . . . . . . . . . . . . . . . . 13

3 Organizing a geometry contest 14

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Introduction to contest preparation . . . . . . . . . . . . . . . 14
3.3 Presentation of the problems . . . . . . . . . . . . . . . . . . 17
3.4 Problem statements . . . . . . . . . . . . . . . . . . . . . . . 18
3.5 Editorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.5.1 Sledding down the mountain . . . . . . . . . . . . . . 34
3.5.2 Pen spinning accident . . . . . . . . . . . . . . . . . . 36
3.5.3 Polar map . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.5.4 Gold paint optimization . . . . . . . . . . . . . . . . . 40
3.6 Results and conclusion . . . . . . . . . . . . . . . . . . . . . . 43

4 Conclusion 45

1
II Handbook of geometry for competitive programmers 47

5 Precision issues and epsilons 48

5.1 Small imprecisions can become big imprecisions . . . . . . . . 48
5.1.1 When doing numerically unstable computations . . . . 49
5.1.2 With large values and accumulation . . . . . . . . . . 50
5.2 Small imprecisions can break algorithms . . . . . . . . . . . . 51
5.2.1 When making binary decisions . . . . . . . . . . . . . 51
5.2.2 By violating basic assumptions . . . . . . . . . . . . . 52
5.3 Modelling precision . . . . . . . . . . . . . . . . . . . . . . . . 52
5.3.1 The issue with “absolute or relative” error . . . . . . . 52
5.3.2 Precision guarantees from IEEE 754 . . . . . . . . . . 54
5.3.3 Considering the biggest possible magnitude . . . . . . 54
5.3.4 Incorporating multiplication . . . . . . . . . . . . . . . 55
5.3.5 Why other operations do not work as well . . . . . . . 56
5.4 Case studies . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.4.1 Problem “Keeping the Dogs Apart” . . . . . . . . . . 57
5.4.2 Quadratic equation . . . . . . . . . . . . . . . . . . . . 62
5.4.3 Circle-circle intersection . . . . . . . . . . . . . . . . . 64
5.5 Some advice . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.5.1 For problem solvers . . . . . . . . . . . . . . . . . . . 67
5.5.2 For problem setters . . . . . . . . . . . . . . . . . . . . 68

6 Basics 69
6.1 Points and vectors . . . . . . . . . . . . . . . . . . . . . . . . 69
6.1.1 Complex numbers . . . . . . . . . . . . . . . . . . . . 69
6.1.2 Point representation . . . . . . . . . . . . . . . . . . . 72
6.2 Transformations . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.2.1 Translation . . . . . . . . . . . . . . . . . . . . . . . . 75
6.2.2 Scaling . . . . . . . . . . . . . . . . . . . . . . . . . . 76
6.2.3 Rotation . . . . . . . . . . . . . . . . . . . . . . . . . . 76
6.2.4 General linear transformation . . . . . . . . . . . . . . 77
6.3 Products and angles . . . . . . . . . . . . . . . . . . . . . . . 78
6.3.1 Dot product . . . . . . . . . . . . . . . . . . . . . . . . 78

2
 6.3.2 Cross product . . . . . . . . . . . . . . . . . . . . . . . 80
6.4 Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.4.1 Line representation . . . . . . . . . . . . . . . . . . . . 86
6.4.2 Side and distance . . . . . . . . . . . . . . . . . . . . . 89
6.4.3 Perpendicular through a point . . . . . . . . . . . . . 90
6.4.4 Sorting along a line . . . . . . . . . . . . . . . . . . . 90
6.4.5 Translating a line . . . . . . . . . . . . . . . . . . . . . 91
6.4.6 Line intersection . . . . . . . . . . . . . . . . . . . . . 92
6.4.7 Orthogonal projection and reflection . . . . . . . . . . 93
6.4.8 Angle bisectors . . . . . . . . . . . . . . . . . . . . . . 93
6.5 Segments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.5.1 Point on segment . . . . . . . . . . . . . . . . . . . . . 95
6.5.2 Segment-segment intersection . . . . . . . . . . . . . . 96
6.5.3 Segment-point distance . . . . . . . . . . . . . . . . . 98
6.5.4 Segment-segment distance . . . . . . . . . . . . . . . . 98
6.6 Polygons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.6.1 Polygon area . . . . . . . . . . . . . . . . . . . . . . . 99
6.6.2 Cutting-ray test . . . . . . . . . . . . . . . . . . . . . 101
6.6.3 Winding number . . . . . . . . . . . . . . . . . . . . . 103
6.7 Circles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.7.1 Defining a circle . . . . . . . . . . . . . . . . . . . . . 108
6.7.2 Circumcircle . . . . . . . . . . . . . . . . . . . . . . . 108
6.7.3 Circle-line intersection . . . . . . . . . . . . . . . . . . 109
6.7.4 Circle-circle intersection . . . . . . . . . . . . . . . . . 111
6.7.5 Tangent lines . . . . . . . . . . . . . . . . . . . . . . . 112

7 3D geometry 116
7.1 Points, products and orientation . . . . . . . . . . . . . . . . 116
7.1.1 Point representation . . . . . . . . . . . . . . . . . . . 116
7.1.2 Dot product . . . . . . . . . . . . . . . . . . . . . . . . 117
7.1.3 Cross product . . . . . . . . . . . . . . . . . . . . . . . 118
7.1.4 Mixed product and orientation . . . . . . . . . . . . . 120
7.2 Planes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
7.2.1 Defining planes . . . . . . . . . . . . . . . . . . . . . . 122

3
 7.2.2 Side and distance . . . . . . . . . . . . . . . . . . . . . 123
7.2.3 Translating a plane . . . . . . . . . . . . . . . . . . . . 124
7.2.4 Orthogonal projection and reflection . . . . . . . . . . 125
7.2.5 Coordinate system based on a plane . . . . . . . . . . 125
7.3 Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
7.3.1 Line representation . . . . . . . . . . . . . . . . . . . . 127
7.3.2 Distance from a line . . . . . . . . . . . . . . . . . . . 129
7.3.3 Sorting along a line . . . . . . . . . . . . . . . . . . . 129
7.3.4 Orthogonal projection and reflection . . . . . . . . . . 129
7.3.5 Plane-line intersection . . . . . . . . . . . . . . . . . . 130
7.3.6 Plane-plane intersection . . . . . . . . . . . . . . . . . 131
7.3.7 Line-line distance and nearest points . . . . . . . . . . 132
7.4 Angles between planes and lines . . . . . . . . . . . . . . . . . 134
7.4.1 Between two planes . . . . . . . . . . . . . . . . . . . 134
7.4.2 Between two lines . . . . . . . . . . . . . . . . . . . . 135
7.4.3 Between a plane and a line . . . . . . . . . . . . . . . 136
7.4.4 Perpendicular through a point . . . . . . . . . . . . . 136
7.5 Polyhedrons . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
7.5.1 Definition . . . . . . . . . . . . . . . . . . . . . . . . . 137
7.5.2 Surface area . . . . . . . . . . . . . . . . . . . . . . . . 138
7.5.3 Face orientation . . . . . . . . . . . . . . . . . . . . . 140
7.5.4 Volume . . . . . . . . . . . . . . . . . . . . . . . . . . 142
7.6 Spherical geometry . . . . . . . . . . . . . . . . . . . . . . . . 144
7.6.1 Spherical coordinate system . . . . . . . . . . . . . . . 144
7.6.2 Sphere-line intersection . . . . . . . . . . . . . . . . . 145
7.6.3 Great-circle distance . . . . . . . . . . . . . . . . . . . 146
7.6.4 Spherical segment intersection . . . . . . . . . . . . . 147
7.6.5 Angles on a sphere . . . . . . . . . . . . . . . . . . . . 151
7.6.6 Spherical polygons and area . . . . . . . . . . . . . . . 152
7.6.7 Solid angle . . . . . . . . . . . . . . . . . . . . . . . . 154
7.6.8 3D winding number . . . . . . . . . . . . . . . . . . . 155

A Solutions to the exercises 157

4
B Omitted proofs 160
B.1 Precision bounds for +, −, × . . . . . . . . . . . . . . . . . . . 160

5
 Part I

Main contents

6
Chapter 1

Introduction

In this chapter, we give a short introduction to competitive programming

and the role of geometry in it, then outline the goals and structure of this
thesis.

1.1 About competitive programming

Competitive programming is the participation in programming contests,
which test the participants’ ability to write programs that solve problems of
an algorithmic or mathematical nature in an efficient way.
A typical problem in a programming contest describes the problem to be
solved, specifies how the input data is provided and how the output should
be written. The participant then has to write a program that will read the
input data (typically in stdin), compute the result, then write the output
(typically in stdout).
When the participant submits a program, it will be compiled by the
judging system then executed on a batch of tests, which is designed to
comprehensively test the program in many situations and detect any flaw.
If for each test case the program runs successfully within the time and
memory limits, and the judging system evaluates the answer as correct,
then the solution is Accepted and awarded points. Other verdicts include
Wrong answer if the output is incorrect, Time limit exceeded if the program
took too much time, or Runtime error if the program crashed.
Besides this standard ”read input, compute result, write output” scheme,
there are also interactive tasks, in which the participant’s solution has to
interact directly with the judging system, exchanging information back and
forth. Also, in most tasks, finding a fast enough solution is the main chal-
lenge, there are some tasks in which the memory limit might be quite limit-
ing, or some other resource determined by the problem statement (like the

7
number of queries the solution may ask the judging system, in interactive
tasks).
Contestants are free to implement their solutions in a variety of lan-
guages, but C++ is the most popular, because of its execution speed and
relatively rich standard library. To succeed in contests, good implementa-
tion skills and a mastery of the language used are as important as talent in
algorithm design and problem solving.
For more details about competitive programming, see [4].

1.2 Types of programming contests

Programming contests can be mostly classified under four categories. The

type of problems is generally the same across the board, but the contest
formats vary a lot.

Olympiads in Informatics Often called OIs, olympiads in informatics

are contests for secondary school students. The most famous OI is the IOI
(International Olympiad in Informatics), held every year for about a week in
the summer. National OIs organized in most countries, usually as part of the
selection process for IOI, and there are also many regional OIs, like APIO
(Asia-Pacific), Balkan OI, CEOI (Central Europe), etc. OIs are individual
contests and are characterized by relatively few tasks (at IOI, 3 tasks for 5
hours), each containing many subtasks that give partial score to partial or
suboptimal solutions.

ACM-ICPC Composed of the World Finals, dozens of regionals serving

as qualifiers, and many subregionals for local practice, the ACM-ICPC con-
tests are for teams of 3 university students. Teams have 5 hours to solve
usually 9-13 problems. All problems are worth 1 point even though their
difficulty varies greatly, and ties are broken with submission times, so speed
is key. There is no partial score.

Regular online contests A handful of websites hold regular individual

contests all through the year, at a rate of about one contest per week. Fa-
mous contest platforms include Codeforces, AtCoder, CodeChef and CS
Academy. Those contests are usually about 2 hours in length, with 4-5
problems whose score varies according to the difficulty. Although the con-
tests are mostly for fun, after the contest, the contestants’ rating, which is
a reflection of their recent performance, is updated.

8
Corporate contests Several IT companies organize their own annual pro-
gramming competitions to advertize themselves and recruit talented pro-
grammers. Those generally consist of one or more online qualifiers and one
onsite final with prizes. The format of the contests is very similar to regular
online contests. Well-known examples include Google Code Jam, Facebook
Hacker Cup and Yandex Algorithm.

1.3 Geometry in competitive programming

Computational geometry problems commonly appear in all contest types

mentioned in section 1.2, except in OIs, where it is mostly avoided. Indeed,
there are strong arguments against the use of problems which might cause
numerical difficulties in pre-university competitions [2], and this is reflected
in the IOI syllabus [5].
In recent years, geometry has been flourishing, especially in ACM-ICPC
contests, where problemsets nearly always include at least one geometry
problem. They are often among the hardest problems of the contest, and
thus have an important role in determining the winners. For this, and
because special training on geometry problems can greatly increase the speed
and accuracy at which a contestant is able to solve a problem, mastery of
geometry has been called a key to success at the World Finals.
But geometry is also a controversial subfield of competitive program-
ming, as many people get frustrated when their code fails due to precision
issues or forgetting to handle some edge cases, which are more frequent than
in other types of problems. It is also often the case that contestants stum-
ble on simple geometry subroutines if they are not used to juggling with
geometry primitives and have never formally studied the subject.
Currently, the vast majority of geometry problems asked in contests are
2D problems, though occasional forays into 3D can also be seen, for example
at NWERC 20151 or Google Code Jam 20182 .

1.4 Goals and structure of this thesis

We believe that the main reason why many contestants feel a certain dislike
towards geometry problems is that they base most of their knowledge of
computational geometry from their basic euclidean geometry knowledge,
and from occasionally browsing the web to read about specific algorithms or
1
Northwestern Europe Regional Contest 2015, Problem F “Flight Plan Evaluation” by
Per Austrin. https://open.kattis.com/problems/flightplan
2
Google Code Jam 2018, Round 3, Problem “Raise the Roof”. https://codejam.
withgoogle.com/2018/challenges/0000000000007707/dashboard/000000000004b90d

9
primitives and to seek code snippets. As such, they never studied the subject
formally and aren’t always aware of the best practices to follow, and all the
issues that can happen if they do it wrong. Also, if they are inexperienced,
they may often get stuck on basic tasks that they never learned to do.
In order to remedy this situation, our first goal was to write a compre-
hensive and practice-oriented reference on the basic tools of computational
geometry, to help raise the general knowledge of contestants, and give prob-
lem setters a strong basis to create problems from. We realized this as a
freely available handbook of geometry for competitive programmers, which
is given in part II. It is still being worked on, and more information on
the approach, the current content covered and the plans for the future are
outlined in chapter 2.
Because we feel that geometry in programming contests has the potential
to be a wider and more varied subject than it is at the moment, in particular
by incorporating more 3D problems, our second goal was to showcase some
innovative notions and elements that could be used in more contests in the
future. We realized this by organizing an online contest composed entirely of
geometry problems, each introducing some geometric elements and notions
that are rarely seen in current contests, and focusing on 3D geometry. The
organization of the contest is presented in chapter 3.
The overall structure of this thesis is as follows:
• Part I contains the main contents of the thesis, namely this intro-
duction (chapter 1), a presentation of the handbook and the writing
approach (chapter 2), a report on the organization of the online con-
test (chapter 3), and some concluding notes on the work in this thesis
(chapter 4).
• Part II contains the handbook itself, as described in chapter 2. Because
of the page limit on the main contents of a Master’s thesis, it should
be considered to be an appendix.

10
Chapter 2

Writing a handbook of
geometry

In this chapter, we explain the approach that was taken while writing the
handbook in part II, outline some points of interest in the current contents,
and talk about future plans for it.

2.1 Approach and writing style

In order to fulfill its mission as a standard and accessible reference for geom-
etry in programming contests, and to adequately adapt the material to its
target audience, we worked in line with the following the following princi-
ples. Of course, satisfying all of them at the same often proved challenging,
so in many cases we had to try out many different explanations and imple-
mentations until we could reach a good compromise.

Low prerequisites Because the main target audience is undergraduate

students or younger, and not all of them have a very advanced level in math,
special care was taken to start from the very basics whenever possible, and
when necessary not assume a level in mathematics higher than what is taught
in high school.

Practice-oriented To accomodate for an audience that likely just wants

to know how to implement the problem they are interested in, even in more
theoretical considerations we are careful to go straight to the point and
always complement the new notions that are introduced with their imple-
mentation and practical uses.

11
Abundance of figures In an effort to make the discussion simple and
clear, we privileged explaining our ideas and the different situations that
might occur using figures whenever possible. Though creating all those
figures seriously increased the writing time, we believe that they are one of
the best features of this handbook.

Short and consistent code A defining feature of this handbook is that

it provides sample code for all algorithms explained. Because contestants
in many contests such as the ACM-ICPC, all code has to be written from
scratch during the contest, the implementations are designed to be as short
as possible while remaining clear, efficient and easy to use. The code snippets
taken together are meant to form a complete library, and effort was put into
its practical reusability and modifiability.

Managing precision issues As explained in the next section, we have

a whole chapter dedicated to ways in which precision issues can arise and
how to manage them. In addition, despite the length constraints that we
tried to stick to, we made sure to make all of our code snippets as robust to
precision issues as they can be, and we highlighted the cases in which the
reader needs to pay extra attention to them.

2.2 Current contents

Because we believe that the foundations of computational geometry in 2D

and 3D are the areas that have the most urgent need for such a manual,
rather than the more complex algorithms that are built on it, that is what
we started with, while the next section describes our future plans. There
are three large chapters in the current state of the handbook.

Precision issues and epsilons This chapter aims to show readers ways
in which geometric computations can go wrong because of floating-point
imprecisions, and how to make them go right. In a crucial part, we present
a model that can provide guarantees on absolute error for some operations,
based on constraints of magnitude and dimensionality. We believe this model
will be useful in practice for both contestants and problem solvers to prove
the correctness of their solutions.

Basics of 2D geometry This chapter provides a complete view of the

basic operations of computational geometry in 2D, exploring topics such as
segment intersection, tangents to two circles, areas, winding number, and
various manipulations on lines. It builds all of this from a blank slate,

12
starting with vectors and dot/cross product and building up from there,
providing intuitive explanations and easy implementations all along the way.

3D geometry This chapter takes much the same approach as the its 2D
equivalent, building up from the dot and cross products and showing how
to do many operations on planes, lines, polyhedrons, as well as a reason-
able introduction to spherical geometry, always trying to foster an intuitive
understanding in the reader. To our knowledge, this is one of the first
references that provide a comprehensive overview of the foundations of 3D
computational geometry in such a practical manner with accompanying code
snippets.

2.3 Publication and future plans

The handbook is currently hosted on the author’s personal website at https:

//vlecomte.github.io/cp-geo.pdf, and has already been shared on the com-
petitive programming community Codeforces, where it has received an over-
whelmingly positive reception.
While we are already proud of what has been accomplished, it is far from
done, and we will continue to expand it and make it freely available under a
CC-BY-SA license. We are planning to make it a complete reference on all
topics in computational geometry that are relevant in a competitive context.
Here are the planned next steps.

Sweep algorithms An overview of famous sweep-line and sweep-angle

algorithms, including algorithms for convex hull, the segment intersection
problem, closest pair problem, etc.

Applications of convex hulls An exposition of techniques linked to con-

vex hulls, such as the O(log n) point-in-polygon query, an O(log n) way to
cut a convex polygon by a line, O(log n) point-to-polygon distance, rotating
calipers, etc.

Practice problems We are planning to link to collect practice problems

for each section whenever possible, so that readers can directly put what
they learn into practice as they are reading the book.

13
Chapter 3

Organizing a geometry
contest

In this chapter we present the content and results of the experimental ge-
ometry contest that we organized.

3.1 Introduction
The goal of organizing this contest was threefold:
• First, to gauge how prepared the competitive programming public is
to problems which involve notions or techniques that are not often
seen in regular contests.
• Secondly, to bring those notions and techniques into the light in the
hope that they would be more easily used in later contests in order to
widen the scope of geometry in programming contests.
• Thirdly, to study the reception of those new types of problems by the
participants: would they appreciate their originality or be discouraged
by the work needed to solve them?
In the rest of this chapter, we present the general process of contest
preparation, present the problems that were prepared for the contest, give
their full problem statements and solutions, and draw our conclusions from
the organization and the results of the contest.

3.2 Introduction to contest preparation

Newcomers to problem setting are almost always surprised by the quantity
of work that goes into preparing a contest task, when they do it for the first
time. Although finding a good problem idea and the intended solution is the

14
most important part of the process, it’s only a small part of the preparation
time. Here we present the typical steps that a problem setter has to go
through to use their task in a contest.

Finding the idea Of course, the first step is to imagine the problem.
There are two main schools for creating problems: some have a clear idea
from the start of what algorithm they would like the intended solution to use
and build the problem and context around that, while some start from ev-
eryday situations or interesting question and from there figure out if they’re
solvable and interesting.

Fixing the details and constraints Often, a single idea can lead to
several possible variants that can be reached by adding or removing elements
from the problem, or adjusting the input limits to accept slower solutions or
not. It is the work of the problem setter to determine which version will be
the most interesting and fun to solve for the contest that is targeted. This
step is particularly crucial when the contest awards partial marks for partial
or suboptimal solutions. An overview of methods to find problem ideas and
refining them is given in [1].

Writing the problem statement This is usually not the most time-
consuming step, especially if the problem is described in a concise way (which
is in general appreciated by the participants). But creating figures to illus-
trate the problem and the sample inputs/outputs can take some time. If the
statements are available in multiple languages, then translation and keeping
the different versions synchronized requires some work as well.

Implementing correct and incorrect solutions In order to verify the

strength of the test data, we need both correct and intentionally incorrect
solutions (because they give the wrong answer, are too slow, crash, use too
much memory, etc.). It is often useful to have several people implement the
correct solution, and to make many solutions based on the correct solution
but with very small mistakes. It is typical that quite a few solutions that
were intended to be correct turn out to be incorrect as more tests are added.

Generating the test data This is usually the most time-consuming step.
As a general rule, generating input data that reach all the desired limits and
make all incorrect solutions fail is a tedious task, and the algorithmic chal-
lenges that arise when generating the test data often turn out to be more
challenging than the actual task. The input is generated by an independent

15
script, and besides tests described imperatively, a reasonable use of random-
ness can be useful to make incorrect approaches produce wrong answers. The
output is typically generated using the official solution.

Validating the test data Because generating the test data is a challeng-
ing task, problem setters often make mistakes, and some inputs end up not
respecting the constraints given in the problem statement. So an important
step is to make another script that will read the input data and verify that
it has all the properties it should have. To avoid repeated mistakes, this is
sometimes done by a person other than the person who generated the test
data. Depending on the problem, this step can range from trivial to very
hard (tasks “Pen spinning accident” and “Gold paint optimization” in this
contest are good examples).

Implementing output checkers (optional) In some tasks, there is a

unique answer, so the output can be compared to the official output by some
diff (sometimes ignoring whitespace). But in others, there are multiple
possible answers, or the answers are floating-point value which are accepted
with some tolerance. Those cases require a checker program, which given
the input, the official output, and the contestant’s output will determine
whether the contestant’s output should be accepted.

Implementing interactors (optional) Some cases are based on an in-

teraction between the contestant’s program and the judging system, which
requires a programs that will handle this interaction and evaluate the pro-
gram.

Testing that solutions get the right verdict Once all the previous
steps have been completed, it is time to verify that all solutions are given
the expected verdicts and the correct number of points. Besides, to make
sure that this will still hold if the implementation is slightly different or in a
different languages, margins should be taken. For example, if the time limit
is T seconds, all correct solutions should pass in less than T /k seconds,
and all slow solutions should take at least kT seconds on some tests, for
some k ≥ 2. Also, solutions that give wrong answers should do so on more
than 1 test. Reaching those standards is not always easy, and often requires
increasing the input constraints and the time limits, at the expense of a
higher load on the judging system during the contest. This testing step can
be made easier by tools that automate this process to various degrees.

Beta-testing the tasks When the task is in the late stages of preparation,
they are usually sent out to several people for testing and comments. This

16
phase is very useful to determine the difficulty of the task, improve some
aspects of it, and strengthen the test data by testing it against more incorrect
solutions. Sometimes, a task has to be dropped because an unexpected
simpler solution appears and reduces the interest of the problem. Another
reason to drop a problem is if many heuristic solutions happen to solve the
problem correctly in the average case, and it is too hard to increase the test
data to make all of them fail (as well as all those which you might not have
thought of). We would like to warmly thank Nicolas Radu who accepted to
beta-test the present contest and provided crucial feedback.

Setting up and announcing the contest The tasks should be set up

and tested on the judging platform that will be used during the contest.
In case this is an online contest, it should be announced and advertized in
advance.

Monitoring the contest Despite all the precautions taken while prepar-
ing the tasks, it often happens that some unexpected solutions get more
or less points than they should. In this unfortunate situation, the authors
have to figure out if the issue can be fixed and either add more test cases
or change the constraints as soon as possible, then rejudge all solutions in
hope that this will solve the problem. Of course, this requires monitoring
the solutions that are submitted and understanding them. An other impor-
tant activity during the contest is to answer the requests for clarification
that are sent about the problem statements.

Writing the editorials Once the contest is over, the problem authors
generally publish editorials, that is, descriptions of the intended solution for
each problem. This allows participants to find out how to solve the problems
that they couldn’t solve during the contest. Most platforms allow users to
submit solutions unofficially after the contest for practice, an activity called
upsolving.

3.3 Presentation of the problems

Here we present the problems that were prepared for the contest, and the
new notions or techniques they included.

Problem A: Sledding down the mountain You are given a polygonal

mesh and a starting point, and have to compute the total area that can be
reached by travelling along the mesh with nonincreasing z. This is essentially
a reachability graph problem, but on an unusual setting: a polygonal mesh

17
in space. The aim of this problem was to test if contestants can see through
the setting and discover the graph problem that lies behind, and also to be
a model for future problems using the same object.

Problem B: Pen spinning accident You are given two rotating lines in
space and asked whether those two lines will eventually cross, and if so when.
To come up with the intended solution, there were two difficulties: knowing
some criterion that determines whether two lines are skew, and manipulating
a mathematical expression with enough skill to make the implementation
easy. It is our hope that the handbook has solved the first difficulty from
now on.

Problem C: Polar map You are given a country on Earth determined

by successive points on its border, linked consecutively by great-circle paths,
and are asked to determine its area in some map projection. This problem
was meant to showcase a technique to compute the area of a region based on
a piecewise parametric representation of its boundary. Although in this case,
the area computation is the whole problem, in the future, this technique is
intended to be used as a subroutine in a larger problem.

Problem D: Gold paint optimization This problem introduces solid

angles, a notion probably new to most contestants, and asks them to max-
imize a solid angle given some limited resource. Although it is challenging
in its own right, the aim of this problem was to give publicity to this new
geometric notion that could be used in future tasks.

3.4 Problem statements

Hereafter we include the problem statements of the five tasks, in their origi-
nal form. The judge solutions, input generators, input validators and output
checkers are available as an attachment to this thesis and also at the follow-
ing url: https://vlecomte.github.io/set/geo18/geo18.zip.

18
 Sledding down the mountain
Writer: Victor Lecomte
Time limit: 12 s Memory limit: 256 MB

You are on vacation in the mountains, and are going on a crazy sled ride
through hilly terrain. You can easily go down a slope and you can also
travel while staying at constant height, but you can’t go up, that is, your
z-coordinate is nonincreasing.
The surface of the mountain is formed of triangle faces linked together
at their edges. There are no vertical slopes and no overhangs. You should
always stay on those triangle faces, but you are allowed to move on their
edges and to move from one triangle to another if they share an edge.
Given a starting point on the mountain, what is the total surface oc-
cupied by the points that you could reach on the mountain without going
up?

Input

The first line of the input contains one integer n, the number of triangles
in the mountain. Then follow n groups of 3 lines. The ith group contains
three 3D points Pi,1 , Pi,2 , Pi,3 , the vertices of the triangle, each one one
line. Each vertex is described by 3 space-separated integers xi,j , yi,j , zi,j ,
its coordinates. The z-coordinate represents the height, while the x- and
y-coordinates represent the position of the point on a map of the mountain.
Your starting point is P1,1 .

Output

Output a floating-point value on a single line: the total area of the mountain
that you can reach on your sled without going up. The answer should be
accurate to an absolute or relative error of 10−6 .

Limits

• 1 ≤ n ≤ 105 ;

• −105 ≤ xi,j , yi,j , zi,j ≤ 105 ;

• the vertices of a triangle are given in counter-clockwise order, that is,

# » # »
the z-coordinate of Pi,1 Pi,2 × Pi,1 Pi,3 is positive;

• the mountain is connected, that is, you can go from any triangle to
any other triangle by passing through common edges;

1/4
 Sledding down the mountain

• if two triangles touch, they share either an entire edge, or one vertex;

• no point in a triangle is directly above or below another triangle.

Example 1

stdin stdout
1 0.707106781187
0 0 0
1 -1 -1
1 1 1

This mountain has only one triangle. You start at point (0, 0, 0) and you
can ride your sled to the whole lower half of the triangle, that is, you can
ride to any point on the triangle of vertices (0, 0, 0), (1, −1, −1) and (1, 0, 0)
√ √
2
(in gray). This is a right triangle with sides 1 and 2, so its area is 2 .
Below on the left is a 3D view of the mountain, and on the right a view
from above, with the height marked at every vertex. The starting point is
marked with a dot in the 3D view, and the reachable region is highlighted.
y
z
y
1

0
x
x
-1

2/4
 Sledding down the mountain

Example 2

stdin stdout
3 1.247219128925
1 2 1
0 2 2
1 1 1
1 1 1
2 2 2
1 2 1
0 0 -1
1 1 1
0 2 2

This mountain has three triangles. Triangle 1 has the edge from (1, 2, 1) to
(1, 1, 1) in common with triangle 2, and the edge from (1, 1, 1) to (0, 2, 2)
in common with triangle 3. You start at point (1, 2, 1), at height 1. You
cannot climb up triangles 1 or 2, so the area that you cover on them is zero.
But you can travel on the edge from (1, 2, 1) to (1, 1, 1) at constant height
to get to triangle 3. From there, you can reach 32 of the area of triangle 3,
√
2 14
which gives the answer 3 × 2 .

y
2 1 2
z
y
1

-1
x
x

3/4
 Sledding down the mountain

Example 3

stdin stdout
2 1.837117307087
1 0 1
0 0 0
1 -1 -1
1 -1 -1
0 0 0
0 -1 1

y
z
y

0 1
x
x
1 -1

4/4
 Pen spinning accident
Writer: Victor Lecomte
Time limit: 1 s Memory limit: 256 MB

You and your friend are huge pen spinning experts, and since it was getting
too easy you decided to take it to the next level by mounting deadly lasers
on both ends of your pens. While you don’t worry much about accidentally
hurting people, there is one safety guideline that you must respect: much
like in a famous ’80s movie, you should never cross the laser beams, because
it would be. . . bad. So you would like to know when the beams are going to
cross, if ever, so that you can safely stop before it happens.
In the rest of the statement, you will be called “person 1” and your
friend “person 2”. Person i is currently spinning their pen around point Pi
in space at a constant rate of 1 radian per second. At time t their pen is
#»
pointing in direction di (t) = (cos t)v#»i + (sin t)w
#», that is, the laser beams on
i
#»
both ends run along the line containing points Pi and Pi + di (t). You can
consider that the length of the pen is negligibly small, so that the whole line
is covered by the laser beams.

er
las
#»
w #»
i
di (t)
t
Pi v#»i

er
las

Input

The output is made of 2 groups of 3 lines, separated by a blank line. The ith
group contains the values Pi , v#»i , w
#» on separate lines. Each of them consists
i
of three space-separated integers: their x-, y- and z-coordinates.

Output

The output is a single line. Print the earliest time t > 0 at which the beams
cross, if it exists. Otherwise, print the word never. The time should be
accurate to an absolute error of 10−7 .

1/5
 Pen spinning accident

Limits

• all coordinates are integers in [−100, 100];

• P1 6= P2 (you are at distinct locations);

#»
• v#»i · w
#» = 0 and kv#»k = kw
i i
# »k =
i 6 0 (so direction di (t) rotates on a circle);
#» #» #»
• d1 (t) × d2 (t) 6= 0 for all t (the beams are never parallel);

• the laser beams are not touching at time 0;

• you will never shoot each other with your lasers, that is, P1 is not on
#»
the line containing P2 and P2 + d2 (t) for any t, and vice versa.

Example 1

stdin stdout
1 0 0 0.785398163397
0 0 1
1 0 0

0 1 0
0 1 0
0 0 1

In this example, the starting directions of the pens are (0, 0, 1) and (0, 1, 0),
so the lines formed by their lasers are at x = 1, y = 0 and x = 0, z = 0 re-
spectively. After π/4 seconds, pen 1 points in direction √12 (1, 0, 1) while pen
2 points in direction √12 (0, 1, 1), so that both lines contain point (0, 0, −1).
This is the first time they touch.

z z z

y y y
x x x

π π
t=0 t= 4 t= 2

2/5
 Pen spinning accident

Example 2

stdin stdout
1 0 0 never
0 0 1
1 0 0

0 1 0
0 1 0
0 0 -1

This example is identical to the first, except that the second pen rotates in
the opposite direction.

z z
z

y y
x x
y
x

π π
t=0 t= 4 t= 2

Example 3

stdin stdout
0 0 0 never
1 0 0
0 1 0

0 0 1
0 1 0
-1 0 0

In this example, the lasers of the first pen only reach points for which z = 0,
while the lasers of the second pen only reach points for which z = 1, so they
clearly never touch.

3/5
 Pen spinning accident

z z z

y y y
x x x

π π
t=0 t= 4 t= 2

Example 4

stdin stdout
1 0 0 0.392699081699
-1 0 -1
-1 0 1

0 1 0
0 1 0
0 0 1

z z z

y y y
x x x

π π
t=0 t= 4 t= 2

Example 5

stdin stdout
0 0 1 0.511669644114
0 -1 1
0 1 1

-1 0 -1
-1 0 0
0 -1 0

4/5
 Pen spinning accident

z z z

y y y
x x x

π π
t=0 t= 4 t= 2

Example 6

stdin stdout
0 -1 0 0.785398163397
-1 0 0
0 0 -1

1 0 0
0 0 -1
0 1 0

z z
z

y y
x x y
x

π π
t=0 t= 4 t= 2

5/5
 Polar map
Writer: Victor Lecomte
Time limit: 8 s Memory limit: 256 MB

You live on the North Pole, and are frustrated that your house is located
on the edge (or even outside) of most world maps. So you have decided to
create your own map, with two criteria: the North Pole should be in the
center, and distances from it should be conserved. The azimuthal equidistant
projection 1 is perfect for this.
In the azimuthal equidistant projection, the map is a circle of radius
1, and a point of latitude ϕ and longitude λ (given in degrees) will be
◦
represented at position (d cos λ, d sin λ), where d = 90180−ϕ
◦ .

λ = 90◦

λ = 135◦ ϕ = −45◦ λ = 45◦

ϕ = 0◦

ϕ = 45◦

λ = 180◦ λ = 0◦

λ = −135◦ λ = −45◦

λ = −90◦

Now, consider a country, whose border is determined by some border

points, where each border point is linked to the next by the shortest path
along the Earth’s surface (the great-circle distance 2 ). What is the area
occupied by that country on your map?

Input

The first line of the input contains one integer n, the number of border points
of the country. Then follow n lines, the ith of which contains two integers
ϕi and λi , the latitude and longitude of the border point, in degrees. The
points are given in counter-clockwise order, that is, when going from point
i to point i + 1, the inside of the country is on the left side.
1
See https://en.wikipedia.org/wiki/Azimuthal_equidistant_projection for a
more in-depth introduction.
2
See https://en.wikipedia.org/wiki/Great-circle_distance for a more in-depth
introduction.

1/3
 Polar map

Output

Output a floating-point value on a single line: the area occupied by the

country on your map. The answer should be accurate to an absolute error
of 10−7 .

Limits

• 3 ≤ n ≤ 103 ;
• −85 ≤ ϕi ≤ 85, −180 < λi ≤ 180;
• the Earth is a perfect sphere (sorry, flat earthers);
• the country does not self-intersect;
• no two consecutive points on the border of the country are exactly
opposite each other;
• the country contains neither the North Pole, nor the South Pole;
• no border of the country will come closer than 2 × 10−4 to the center
of the map (North Pole) or to the border of the map (South Pole).

Example 1

stdin stdout
3 0.269064434316
45 0
-45 0
0 90

The border points of the country are located at (0.25, 0), (0.75, 0) and (0, 0.5)
on the map. However, the area is not 1/8 because the borders of the country
are not straight lines on the map.

2/3
 Polar map

Example 2

stdin stdout
6 0.389591701512
0 90
0 180
0 -90
80 -90
80 180
80 90

Between the first three points, the border runs along the equator, which is
a circular arc on the map. The area is a bit less than π/8.

Example 3

stdin stdout
3 0.207400294880
-85 0
-85 179
0 90

3/3
 Gold paint optimization
Writer: Victor Lecomte
Time limit: 10 s Memory limit: 256 MB

You are working on a modern art piece consisting of n cubes of side 1 m

in space. The cubes are currently unpainted, and that’s a bit boring, so
you have decided to buy some gold paint to decorate them. Since the gold
paint is made of real gold, it’s very expensive, so you only have l liters. One
liter can paint a surface of 1 m2 . You are allowed to distribute the paint
completely as you wish, painting only some of the cubes, only some of the
faces of a given cube, and even only part of a given face.
The visitors will come to see your work at point (0, 0, 0), so you would like
to optimize your use of the paint so that the part of their field of view that
is covered by gold paint is as large as possible, that is, the total solid angle
subtended at (0, 0, 0) by the visible painted parts of the cubes is maximized.
Paint does not count if it is placed on faces that are not visible from the
origin because they are on the wrong side of the cube.
To achieve this goal, how much paint should you use on each of the
cubes?
Solid angle
Just like the planar angle subtended by an object is the length of the
object once it is projected onto a unit circle around the point, the
solid angle subtended by an object is the area of the object once it is
projected onto a unit sphere around the point.
See https://en.wikipedia.org/wiki/Solid_angle for a complete
definition.

planar angle solid angle

Input

The first line of the input contains two integers n and l, the number of
cubes and the quantity of paint in liters. Then follow n lines, the ith of
which contains three integers xi , yi , zi , meaning that there is an axis-aligned
unit cube at [xi , xi + 1] × [yi , yi + 1] × [zi , zi + 1].

1/3
 Gold paint optimization

Output

The output consists of n lines, the ith of which contains a floating-point

value li , the number of liters of paint that should be used on cube i. The
numbers should be accurate up to a relative or absolute error of 10−4 . It can
be proven that the solution is unique under the constraints of this problem.

Limits

• 1 ≤ n ≤ 104 ;
• 0 ≤ l < 3n;
• 0 ≤ xi , yi , zi < 100, which means that the faces visible from the origin
are in planes x = xi if xi 6= 0, y = yi if yi 6= 0 and z = zi if zi 6= 0;
• no cube touches the origin;
• no cube hides any part of another cube, that is, no ray from the origin
touches more than one cube;
• you don’t have enough paint to cover all visible faces, that is, if you
had more paint, you could strictly increase the solid angle subtended
at the origin by the visible painted parts.

Example 1

stdin stdout
2 1 0.50000000
2 0 0 0.50000000
0 2 0

You have 1 liter to paint two cubes at [2, 3] × [0, 1] × [0, 1] and [0, 1] × [2, 3] ×
[0, 1]. They are at equal distances from (0, 0, 0) and have only one visible
face from there, at x = 2 and y = 2, respectively. It is optimal to use half
of the paint on each face.
Here is what the visible face of the first cube looks like from the origin,
with the painted part highlighted:
z

2/3
 Gold paint optimization

Example 2

stdin stdout
2 2 1.00000000
2 0 0 1.00000000
10 10 10

You have 2 liters to paint two cubes at [2, 3] × [0, 1] × [0, 1] (one visible face)
and [10, 11] × [10, 11] × [10, 11] (three visible faces). It is optimal to paint
the visible face of the first cube completely, then to use the remaining liter
to paint part of the three faces of the second cube.

Example 3

stdin stdout
2 2 0.98985432
2 0 0 1.01014568
0 1 1

3/3
3.5 Editorial

This section contains the editorial of the contest, that is, a description of
the main ideas of the intended solution, for each of the four problems that
were used in the contest. It was published on the contest site right after the
contest.

3.5.1 Sledding down the mountain

In this problem I wanted to experiment with graph-like problems on a poly-

hedral mesh. My aim was to show that the added dimension of height could
make interesting ideas possible.

Idea

The first observation to make is that if we can reach a triangle at height

h, then we can reach all points of the triangle at height ≤ h. So for each
triangle i, we want to find the highest height hi at which it can reached from
P1,1 .
A first idea would be to build a graph from the vertices of the triangles
and determine for each of them whether it is reachable, with some kind of
flood fill. However, this is insufficient, as sometimes the critical height hi is
not the height of any vertex of the triangle, like in the left triangle below.

y
z
y

-2 0 -1
x
x
-2

A better idea is to build a graph on the triangles of mountain, where

two triangles are linked if they share an edge. Let’s figure how to do the
relaxations between two triangles. Suppose triangles i and j share an edge,
such that the lowest point of the edge has height hlo and the highest point
of the edge has height hhi . If triangle i can be reached at hi , what height
can we reach in j using that edge?
There are three cases:
• if hi < hlo , triangle j cannot be reached from triangle i;

34
 • if hlo ≤ hi ≤ hhi , it can be reached with a height of hi ;
• if hi > hhi , it can be reached with a height of hhi .
Since in all cases the height that is reached is smaller or equal to hi , we
can use Dijkstra’s algorithm to efficiently compute hi for all i. We maintain
the best known height for every triangle, and always select the unvisited
triangle that has the highest height.

Cutting the triangles

Now that we found hi for all triangles i, we need to find the part of the
triangle that is under plane z = hi . This is a similar exercise to cutting a
polygon by a line in 2D: we need to keep the points for which z ≤ hi and
add points whenever a edge goes through the plane. This can be simply
implemented this way:
// Assume p3 is a 3D point structure with basic operators

p3 planeInter(p3 a, p3 b, int h) {
return (a*(b.z-h) - b*(a.z-h))/(b.z-a.z);
}

vector<p3> polygonUnder(vector<p3> ps, int h) {

vector<p3> under;
for (int i=0, n=ps.size(); i<n; i++) {
p3 a = ps[i], b = ps[(i+1)%n];

// Keep points under h

if (a.z <= h)
under.push_back(a);

// Add intersections
if ((a.z-h)*(b.z-h) < 0) // if a and b on either side
under.push_back(planeInter(a,b,h));
}
return under;
}

Finding the area

It turns out finding the area of a polygon in 3D is pretty much the same as
in 2D. In 2D, we can find the area of a polygon P1 · · · Pn as
|P1 × P2 + P2 × P3 + · · · + Pn × P1 |
2

35
where × is the 2D cross product (a scalar). In 3D, if P1 , . . . , Pn are coplanar,
the vector
#»
S = P1 × P2 + P2 × P3 + · · · + Pn × P1
is a vector perpendicular to their plane of polygon P1 · · · Pn and whose norm
is twice the area of the polygon. So we can similarly compute the area as
1 #»
2 k S k.
So we just need to use this formula and for every triangle sum up the
area of the part that is under hi .

3.5.2 Pen spinning accident

There were two ways to approach this problem (that I know of), with wildly
different difficulties of implementation. The first is interesting in that we
transform a 3D problem into a 1D problem. The second shows that good
knowledge of geometric primitives can help you simplify a problem and avoid
a lot of edge cases.

Approach 1: Position on the intersection line

We can observe that when the pens spin around, they each sweep a distinct
plane. So if the pens touch at some point, it must happen on the intersection
of the planes. If it doesn’t exist, the answer is never, otherwise because of
the constraints of the problem, it must be a line l that touches neither P1
nor P2 .
Since we’re only interested in positions on l, let’s set an arbitrary starting
point O on l, and figure out how far from O the lasers of the ith pen touch
l. We’ll call this fi (t).
We can easily convince ourselves that fi (t) is of the form

fi (t) = ci + di cot(t + αi )

where ci is the position of the projection of Pi on l, di is the distance from

Pi to l, and αi depends on the angle between l and v#»i .

ci di cot(t + αi )

O l

t + αi

Pi

36
 Instead of trying to find a root straight away (which would be very
tricky), we can use the summation formula:
cot t cot αi − 1
cot(t + αi ) =
cot t + cot αi

By substituting and eliminating the denominators gives this (rather

lengthy) quadratic equation in cot t which can be used to find t more easily:

0 = (cot t)2 (c2 − c1 + d2 cot α2 − d1 cot α1 )

+ (cot t)[(c2 − c1 )(cot α1 + cot α2 ) + (d2 − d1 )(cot α1 cot α2 − 1)]
+ [(c2 − c1 ) cot α1 cot α2 − (d2 cot α1 − d1 cot α2 )]

Some caveats:
• Since the values of ci , di and cot αi are most likely imprecise, we need
to do an epsilon comparison to test the value of the discriminant and
determine the existence of solutions.
• We also need to handle the cases when cot α1 or cot α2 don’t exist. One
trick is to multiply the whole equation by sin α1 sin α2 , which replaces
cot αi with cos αi and adds some sin αi in the mix.
• Note that we don’t care about the times when cot t doesn’t exist, that
is, t = kπ, since the lasers are guaranteed not to touch at the start.

Approach 2: Vector magic

Given 4 points A, B, C, D in space, we can define the expression

 # » # » # »
orient(A, B, C, D) = AB × AC · AD

which has many properties similar to its 2D counterpart

# » # »
orient(A, B, C) = AB × AC

For example, orient(A, B, C, D) = 0 iff A, B, C, D are coplanar, its sign

determines on which side of plane ABC point D lies, and its norm is 6
times the volume of tetrahedron ABCD. The property we are interested in
here is that it is zero iff lines AB and CD are either parallel or intersecting
(remember that in space, lines can be neither). Since in our case the lasers
are never parallel, we can use this to determine easily whether the lines
intersect.
We can reshuffle it this way:
 # » # » # »  # » # » # »
orient(A, B, C, D) = AB × AD · AC = AB × CD · AC

37
so that in our case, the lasers touch iff
 #» #»  #» #»  # »
orient P1 , P1 + d1 (t), P2 , P2 + d2 = d1 (t) × d2 (t) · P1 P2 = 0
#»
If we plug in the definition of di (t), we obtain
# »
0 = cos2 t (v#»1 × v#»2 ) · P1 P1
# »
+ cos t sin t (v#»1 × w #» + w
2
# » × v#») · P
1 2 1 P2
# »
+ sin2 t (w#» × w
1
# ») · P P
2 1 2

If we divide the equation by sin2 t, we obtain (again) a quadratic equation

in cot t, but this time with no special cases, and all computations can be
done with integers.

3.5.3 Polar map

In this problem, we are interested in finding the area of objects of unusual

shapes. So first we need to find mathematical tools that can help us do that.
The objective was mostly to show this way to compute areas.

Area surrounded by a curve

Given a curve C, how can we find the area it encloses? One way is to compute
the following integral:
1
Z
x dy − y dx
2 C
This can be seen as an infinitesimal version of the shoelace formula, and
computes the surface sweeped by the segment from the origin O to a moving
point on C.
If we know that the curve never goes through O, then we can consider
polar coordinates (r cos θ, r sin θ) and the integral becomes
1
Z
r2 dθ
2 C
r2
Indeed, 2 dθ is the area of circular sector of radius r and angle dθ.
This means that if we describe C in a parametric way, that is, if we
find functions r(t) and θ(t) that describe the coordinates of points on C as
parameter t increases in [a, b], then we can compute the area as
1 b 2
Z
r (t) θ0 (t) dt
2 a
where θ0 (t) is the derivative of θ(t).
For example, let’s say we want to find the area of a circle of radius 1.1
1
Groundbreaking, right?

38
We can define the points of the circle with

r(t) = 1
θ(t) = t

for t ∈ [0, 2π].

Then we can find
1 1 2π 2 1 2π 2
Z Z Z
2 0
r dθ = r (t) θ (t) dt = 1 1 dt = π
2 C 2 0 2 0

Note that the integral can be computed in several parts to handle dif-
ferent parametrizations: for example, this allows us to easily compute the
area of shapes formed by line segments and circular arcs.

Parametrization

Now that we have a way to compute the area of any parametric curve, let’s
try to find a parametrization for the country borders on our map.
Let’s say the Earth has radius 1 and we want to find the path between
two consecutive points A and B on the border of the country. First, we
observe that the “straight line” between A and B actually gives the correct
# »
direction: if we take point P (t) = A + tAB (t ∈ [0, 1]) and scale it so that it
has a norm of 1, then it will lie on the great circle containing A and B. And
since the position on our map only depends on the latitude ϕ and longitude
λ, not on the altitude, we will use this point P (t) directly.
Let’s assume that the axis z = 0 is the line going between the poles.
First, we find the longitude and latitude of P (t):
 q 
ϕ(t) = atan2 Pz (t), Px2 (t) + Py2 (t)
λ(t) = atan2 (Py (t), Px (t))

This gives the following polar coordinates on the map:

π/2 − ϕ(t)
r(t) =
π
θ(t) = λ(t)

We need to find the derivative of θ(t). Here we are using formulas for
the partial derivatives of atan2, see https://en.wikipedia.org/wiki/Atan2#

39
Derivative for more info.

θ0 (t) = λ0 (t) = (atan2 (Py (t), Px (t)))0

Py0 (t)Px (t) − Px0 (t)Py (t)
=
Px2 (t) + Py2 (t)
(By − Ay )Px (t) − (Bx − Ax )Py (t)
=
Px2 (t) + Py2 (t)
Ax By − Ay Bx
= 2
Px (t) + Py2 (t)

Now we can find the part of the integral for this part of the border as

1 1 2
Z
r (t) θ0 (t) dt
2 0

Integration

We didn’t manage to find an antiderivative for the given function to inte-

grate. However, in general numerical integration works very well, so you can
just use that.
For the best precision/time ratio, we advise using something adapta-
tive like adaptative Simpson’s method (see https://en.wikipedia.org/wiki/
Adaptive_Simpson%27s_method). But time limits were lenient enough that
regular Simpson’s rule and even trapezoidal or midpoint rule worked as
well, as long as the step is small enough to detect the brusque changes when
the border passes close to the South Pole as in the third sample.

3.5.4 Gold paint optimization

Some of the difficulty of this problem was to get used to the notion of solid
angle. But actually, an intuitive understanding of it was enough to solve the
problem, since the solution doesn’t require actually computing a solid angle
at any point.

Idea

The main insight was thinking in terms of return on investment: given a

location, if I paint a small area there, by how much does it increase the solid
angle. Thus we consider the ratio
solid angle added
ρ=
paint used

40
It is clear that surfaces with higher ratios should be painted before surfaces
with lower ratios. So we perform a binary search on this ratio ρ, computing
the total area of parts that have a ratio ≥ ρ. If this total area is smaller than
l, we should decrease ρ, otherwise we should increase it. The distribution of
paint after convergence is the optimal distribution of paint.

Computing the ratio

Intuitively, the ratio is inversely proportional to the square of the distance

from O = (0, 0, 0), and it will be lower if the surface is seen at an angle.
More precisely, if the surface is seen from distance r and the angle between
the direction of observation and the normal of the surface is α, then the
ratio is ρ = cos α/r2 .

α
r

This can be seen from a quick drawing or taken from Wikipedia:

r̂ · n̂ dΣ
Z
Ω=
S r2

where Ω is the solid angle, S the surface observed, r̂ the direction of obser-
vation, n̂ the normal of the surface and dΣ is an infinitesimal area.
Now, given a ratio ρ and a cube face, how do we find the part of the face
that has ratio at least ρ? Suppose without loss of generality that the square
is on plane x = d.

d tan α

d sα
α co
d/
r=
O

Clearly, on that plane, the closer to O = (0, 0, 0), the better the ratio. In
particular, if the observed point is at angle α from the perpendicular, then
r = d /cos α, so the ratio is

cos α cos3 α
ρ= =
r2 d2

41
and we can find α as p 
3
α = arccos ρd2
The time limits were lenient enough to allow solutions to find this value by
some binary search instead.
Thus, for the value of α we fond, all points on the plane x = d that are
within a disk of radius d tan α around (d, 0, 0) will have ratio ≥ ρ. So the
relevant points on the cube face are the intersection of that disk and the
square of the cube face (a 2D problem).

Circle-square intersection

So the last thing we need to figure out is how to compute the area of the
intersection of a disk and a square. This is feasible but tedious in the general
case.
Here we are helped by the fact that the square will always be fully within
one of the quadrants of the disk. So we can find it easily by inclusion-
exclusion. Let’s say we have a function f (r, xlo , ylo ) that finds the inter-
section between the circle of radius r and center (0, 0), and the quadrant
x ≥ xlo , y ≥ ylo , for xlo , ylo ≥ 0. Then the area of intersection with square
[x, x + 1] × [y, y + 1] can be found as
f (r, x, y) − f (r, x + 1, y) − f (r, x, y + 1) + f (r, x + 1, y + 1)

B
f (r, xlo , ylo )

(xlo , ylo ) A

Function f can be easily implemented this way, starting by computing

intersection points A and B if they exist:
double quadrantDisk(double r, double x, double y) {
if (x*x + y*y >= r*r)
return 0;
pt p(x,y), a(sqrt(r*r-y*y), y), b(x, sqrt(r*r-x*x));
return (cross(p,a) // triangle OPA
+ r*r*asin(min(cross(a,b)/r/r, 1.0)) // circular sector OAB
+ cross(b,p) // triangle OBP
)/2;
}

42
3.6 Results and conclusion

The contest was organized on the contest platform Codeforces, and is avail-
able at the following address: http://codeforces.com/gym/101793. It took
place on May 6, lasting 4 hours. It seemed likely that no participant would
solve all problems, given their difficulty and the knowledge required to solve
them.
Over 30 people registered for the contest, but only 8 submitted any code.
It is expected that those participants who did not submit either found the
problems too difficult and gave up, or had issues while implementing and
never reached a working solution.
The problems were sorted according to their estimated difficulty (we
presented them in that same order). Two participants solved the first two
problems successfully, while the last two problems were untouched. While
this is slightly disappointing, it was not completely unexpected.
In a feedback form shared after the contest,2 we asked contestants
• their perceived difficulty level of the problems, both while solving them
and after reading the editorials;
• how much they liked/disliked the problems;
• where they felt the difficulty mainly lay (finding the right idea, knowing
the right theory, etc.).
Although the number of responses (8) is rather small, it allows us to draw
some general tendencies.
Our expectation was that contestants would mostly realize the problems
were easier than they thought once they had read the editorials, because
knowing the theory would make the problem more manageable. The results
seem to confirm this since out of 26 difficulty evaluations, in 7 cases contes-
tants thought the problem was easier after reading the editorial, while only
in 2 cases they thought it was harder, and in 17 cases their appreciation
didn’t change.
The difficulty appreciation also seemed to mostly match the expected dif-
ficulty, with problem A being most often called “easy”, problem B “medium”,
problem C “hard” and problem D “impossible”.
It seems that the contestants mostly enjoyed the problems, as all prob-
lems were either “liked” or “loved” by more than 70 % of respondants.
Finally, half of the respondants thought a large part of the difficulty lay
in knowing the right theory, as expected, and another half thought it lay
in finding the right idea, which is typical of a well-made regular contest.
Another popular response was correctly handling edge cases.
2
The full results of which are given as an attachment.

43
 In conclusion, even though we had hoped to have slightly more partici-
pants and submissions, we think that this contest was a success. We hope
that those problems were interesting and that they may pave the way for
more varied geometry problems in the future, and we hope that our hand-
book will serve as a solid reference to supplement the contestants’ knowledge
in the theory points that were not known to all.

44
Chapter 4

Conclusion

In an effort to make geometry problems more accessible to everyone in pro-

gramming contests, we have produced a practice-oriented handbook covering
the basics of both 2D and 3D geometry, as well as an introduction to the
issues that can arise from the use of floating-point data types and how to
overcome them. All notions and algorithms are explained from the ground
up using intuitive explanations, and accompanied by short and cohesive code
snippets and by a large amount of illustrative figures. Notable contributions
are in presenting a model of error propagation based on magnitude condi-
tions and dimensionality of values, and in our chapter about the foundations
of 3D geometry, a topic which has to our knowledge not been treated in such
an implementation-oriented way before.
In addition, to foster variety in geometry problems, we have created,
prepared and organized a public programming contest composed entirely of
geometry problems, in order to showcase innovative notions and techniques
that we hope can be used by other problem setters to build other innovative
problems in the future.

Future work

The handbook we created can still be expanded and improved in many

ways, and we plan to do continue to develop and share it in the future
until it covers most of the computational geometry algorithms relevant to
competitive programming, as explained in section 2.3.
In terms of problem setting, we believe that geometry still has a long
way to go until it reaches maturity. Problems like those we presented in
our contest which are considered difficult today will likely become common
knowledge in a few years, and with this shift, we can expect even more inter-
esting problems and ideas to appear in the future. We encourage problem

45
setters to continue raising the bar in originality, and to delve into fields that
have so far been neglected such as differential geometry and topology.

46
 Part II

Handbook of geometry for

competitive programmers

47
Chapter 5

Precision issues and epsilons

Computational geometry very often means working with floating-point val-

ues. Even when the input points are all integers, as soon as intermediate
steps require things like line intersections, orthogonal projections or circle
tangents, we have no choice but to use floating-point numbers to represent
coordinates.
Using floating-point numbers comes at a cost: loss of precision. The
number of distinct values that can be represented by a data type is limited
√
by its number of bits, and therefore many “simple” values like 0.1 or 2
cannot be exactly represented. Worse, even if a and b are exact, there is no
guarantee that simple operations like a + b, a − b or ab will give an exact
result.
Though many people are well aware that those issues exist, they will
most often argue that they only cause small imprecisions in the answer in the
end, and do not have any major consequence or the behavior of algorithms.
In the rest of this chapter, we will show how both those assumptions can
sometimes be false, then present some ways in which we can make accurate
statements about how precision loss affects algorithms, go on with a few
practical examples, and finally give some general advice to problem solvers
and setters.

5.1 Small imprecisions can become big impreci-

sions

In this section we explore two ways in which very small starting imprecisions
can become very large imprecisions in the final output of a program.

48
5.1.1 When doing numerically unstable computations

There are some types of computations which can transform small impreci-
sions into catastrophically large ones, and line intersection is one of them.
Imagine you have four points A, B, C, D which were obtained through an
previous imprecise process (for example, their position can vary by a dis-
tance of at most r = 10−6 ), and you have to compute the intersection of
lines AB and CD.
For illustration, we represent the imprecisions on the points with small
disk of radius r: the exact position is the black dot, while the small gray
disk contains the positions it could take because of imprecisions. The dashed
circle gives an idea of where point I might lie.
In the best case, when A, B and C, D aren’t too close together, and not
too far from the intersection point I, then the imprecision on I isn’t too
big.

A
C

But if those conditions are not respected, the intersection I might vary in
a very wide range or even fail to exist, if given the imprecision lines AB and
CD end up being parallel, or if A and B (or C and D) end up coinciding.

49
 B
A

C
D

This shows that finding the intersection of two lines defined by imprecise
points is a task that is inherently problematic for floating-point arithmetic,
as it can produce wildly incorrect results even if the starting imprecision is
quite small.

5.1.2 With large values and accumulation

Another way in which small imprecisions can become big is by accumulation.

Problem “Keeping the Dogs Apart”, which we treat in more detail in a case
study in section 5.4.1, is a very good example of this. In this problem, two
dogs run along two polylines at equal speed and you have to find out the
minimum distance between them at any point in time.
Even though the problem seems quite easy and the computations do not
have anything dangerous for precision (mostly just additions, subtractions
and distance computations), it turns out to be a huge precision trap, at least
in the most direct implementation.
Let’s say we maintain the current distance from
√ the start for both dogs.
There are 10 5 polyline segments of length up to 2 × 10 4 , so this distance
√
can reach 2 × 109 . Besides, to compute the sum, we perform 105 sum
operations which can all bring a 2−53 ≈ 1.11 × 10−16 relative error if we’re
using double. So in fact the error might reach
√ 
2 × 109 × 105 × 2−53 ≈ 0.016

Although this is a theoretical computation, the error does actually get

quite close to this in practice, and since the tolerance on the answer is 10−4
this method actually gives a WA verdict.

50
 This shows that even when only very small precision mistakes are made
(≈ 1.11 × 10−16 ), the overal loss of precision can get very big, and carefully
checking the maximal imprecision of your program is very important.

5.2 Small imprecisions can break algorithms

In this section, we explore ways in which small imprecisions can modify the
behavior of an algorithm in ways other than just causing further impreci-
sions.

5.2.1 When making binary decisions

The first scenario we will explore is when we have to make clear-cut decisions,
such as deciding if two objects touch.
Let’s say we have a line l and a point P computed imprecisely, and we
want to figure out if the point lies on the line. Obviously, we cannot simply
check if the point we have computed lies on the line, as it might be just
slightly off due to imprecision. So the usual approach is to compute the
distance from P to l and then figure out if that distance is less than some
small value like cutoff = 10−9 .
While this approach tends to works pretty well in practice, to be sure
that this solution works in every case and choose cutoff properly,1 we need to
know two things. First, we need to know error , the biggest imprecision that
we might make while computing the distance. Secondly, and more critically,
we need to know chance , the smallest distance that point P might be from l
while not being on it, in other words, the closest distance that it might be
from l “by coincidence”.
Only once we have found those two values, and made sure that error <
chance , can we then choose the value of cutoff within [error , chance ).2 Indeed,
if cutoff < error , there is a risk that P is on l but we say it is not, while if
cutoff ≥ chance there is a risk that P is not on l but we say it is.
Even though error can be easily found with some basic knowledge of
floating-point arithmetic and a few multiplications (see next section), find-
ing chance is often very difficult. It depends directly on which geometric
operations were done to find P (intersections, tangents, etc.), and in most
cases where chance can be estimated, it is in fact possible to make the com-
parison entirely with integers, which is of course the preferred solution.
1
And motivated problem setters do tend to find the worst cases.
2
In practice you should try to choose cutoff so that there is a factor of safety on both
sides, in case you made mistakes while computing error or chance .

51
5.2.2 By violating basic assumptions

Many algorithms rely on basic geometric axioms in order to provide their

results, even though those assumptions are not always easy to track down.
This is especially the case for incremental algorithms, like algorithms for
building convex hulls. And when those assumptions are violated by using
floating-point numbers, this can make algorithms break down in big ways.
Problems of this type typically happen in situation when points are
very close together, or are nearly collinear/coplanar. The ways to solve
the problem depend a lot on what the algorithm, but tricks like eliminating
points that are too close together, or adding random noise to the coordinates
to avoid collinearity/coplanarity can be very useful.
For concrete examples of robustness problems and a look into the weird
small-scale behavior of some geometric functions, see [3].

5.3 Modelling precision

In this section, we try to build a basic model of precision errors that we can
use to obtain a rough but reliable estimate of a program’s precision.

5.3.1 The issue with “absolute or relative” error

When the output of a problem is some real value like a distance or an area,
the problem statement often specifies a constraint such as: “The answer
should be accurate to an absolute or relative error of at most 10−5 .” While
considering the relative accuracy of an answer can be a useful and conve-
nient way to specify the required precision of an answer in some cases (for
example in tasks where only addition and multiplication of positive values
are performed), we think that for most geometry problems it is unsuitable.
The reason for this is the need to subtract3 large values of similar mag-
nitude. For example, suppose that we are able to compute two values with
relative precision 10−6 , such as A = 1000 ± 10−3 and B = 999 ± 10−3 . If we
compute their difference, we obtain A−B = 1±2×10−3 . The absolute error
remains of a comparable size, being only multiplied by 2, but on the other
hand relative error increases drastically from 10−6 to 2×10−3 because of the
decrease in magnitude. This phenomenon is called catastrophic cancellation.
In fact, whenever a certain relative error can affect big numbers, catas-
trophic cancellation can cause the corresponding absolute error to appear
on very small values. The consequence is that if a problem statement has a
3
Strictly speaking, we mean both subtraction of values of the same sign, and addition
of values of opposite signs.

52
certain tolerance on the relative error of the answer, and a correct solution
has an error close to it for the biggest possible values, then the problem
statement also needs to specify a tolerance on the corresponding absolute
error in case catastrophic cancellation happens. And since that tolerance on
absolute error is at least as tolerant as the tolerance on relative error for all
possible values, it makes it redundant. This is why we think that tolerance
on “absolute or relative error” is misleading at best.4
Catastrophic cancellation shows that relative precision is not a reliable
way to think about precision whenever subtractions are involved — and that
includes the wide majority of geometry problems. In fact, the most common
geometric operations (distances, intersections, even dot/cross products) all
involve subtractions of values which could be very similar in magnitude.
Examples of this appear in two of the case studies of section 5.4: in prob-
lem “Keeping the Dogs Apart” and when finding the solution of a quadratic
equation.
Another example occurs when computing areas of polygons made of
imprecise points. Even when the area ends up being small, the imprecision
on it can be large if there were computations on large values in intermediate
steps, which is the case when the coordinates have large magnitudes.

area  area
absolute error ≈ absolute error
relative error  relative error

Because of this, we advise against trying to use relative error to build

precision guarantees on the global scale of a whole algorithm, and we recom-
mend to reason about those based on absolute error instead, as we describe
below.
4
In fact, working with relative error tolerances would make sense if this “relative error”
was defined based on the magnitude of the input coordinates rather than on the magni-
tude of the answer, as we will see starting from section 5.3.3. For example, if all input
coordinates are bounded by M , it would make sense to require an absolute precision of
M 2 × 10−6 on an area. But since the answer can remain very small even if the magnitude
of the input grows, requiring a fixed relative precision on it is usually too constraining for
test cases with inputs of large magnitude.

53
5.3.2 Precision guarantees from IEEE 754

Nearly all implementations of floating-point numbers obey the specifications

of the IEEE 754 standard. This includes float and double in Java and C++,
and long double in C++. The IEEE 754 standard gives strong guarantees
that ensure floating-point numbers will have similar behavior even in differ-
ent languages and over different platforms, and gives users a basis to build
guarantees on the precision of their computations.
The basic guarantees given by the standard are:
1. decimal values entered in the source code or a file input are represented
by the closest representable value;
√
2. the five basic operations (+, −, ×, /, x) are performed as if they were
performed with infinite precision and then rounded to the closest rep-
resentable value.
There are several implications. First, this means that integers are rep-
resented exactly, and basic operations on them (+, −, ×) will have exact
results, as long as they are small enough to fit within the significant digits
of the type: ≥ 9 × 1015 for double, and ≥ 1.8 × 1019 for long double. In
particular, long double can perform exactly all the operations that a 64-bit
integer type can perform.
Secondly, if the inputs are exact, the relative error on the result of any
√
of those five operations (+, −, ×, /, x) will be bounded by a small constant
that depends on the number of significant digits in the type.5 This constant
is < 1.2 × 10−16 for double and < 5.5 × 10−20 for long double. It is called
the machine epsilon and we will often write it .

5.3.3 Considering the biggest possible magnitude

We explained earlier why we need to work with absolute error, but since
IEEE 754 gives us guarantees in terms of relative errors, we need to consider
the biggest magnitude that will be reached during the computations. In
other words, if all computations are precise up to a relative error of , and
the magnitude of the values never goes over M , then the absolute error of
an operation is at most M .
This allows us to give good guarantees for numbers obtained after a
certain number of + and − operations: a value that is computed in n opera-
tions6 will have an absolute error of at most nM  compared to the theoretical
5
This assumes the magnitudes do not go outside the allowable range (≈ 10±308 for
±4932
double and ≈ 10 for long double) which almost never happens for geometry problems.
6
Note that when we say a value is “computed in n operations” we mean that it is
computed by a single formula that contains n operations, and not that n operations are
necessary to actually compute it. For example (a+b)+(a+b) is considered to be “computed

54
result.
We can prove the guarantee by induction: let’s imagine we have two
intermediate results a and b who were computed in na and nb operations
respectively. By the inductive hypothesis their imprecise computed values
a0 and b0 respect the following conditions.

|a0 − a| ≤ na M  |b0 − b| ≤ nb M 

The result of the floating-point addition of a0 and b0 is round(a0 +b0 ) where

round() is the function that rounds a real value to the closest representable
floating-point value. We know that | round(x) − x| ≤ M , so we can find a
bound on the error of the addition:

| round(a0 + b0 ) − (a + b)|
=  round(a0 + b0 ) − (a0 + b0 ) + (a0 + b0 ) − (a + b) 
   

≤ | round(a0 + b0 ) − (a0 + b0 )| + |(a0 + b0 ) − (a + b)|

≤ M  + |(a0 − a) + (b0 − b)|
≤ M  + |a0 − a| + |b0 − b|
≤ M  + na M  + na M 
= (na + nb + 1)M 

where the first two steps follow from the triangle inequality. Since the sum
is “computed in na + nb + 1 operations”, the bound of (na + nb + 1)M  that
is obtained is small enough. The proof for subtraction is very similar.

5.3.4 Incorporating multiplication

The model above gives good guarantees but is very limited: it only works for
computations that use only addition and subtraction. Multiplication does
not give guarantees of the form nM . However, we can still say interesting
things if we take a closer look the different types of values we use in geometry:
• Adimensional “0D” values: e.g. angles, constant factors;
• 1D values: e.g. coordinates, lengths, distances, radii;
• 2D values: e.g. areas, dot products, cross products;
• 3D values: e.g. volumes, mixed products.
Usually, the problem statement gives guarantees on the magnitude of
coordinates, so we can find some constant M so that all 1D values that will
be computed in the code have a magnitude less than M . And since 2D and
3D values are usually created by products of 1D values, we can usually say
in 3 operations” even though we can implement this with only 2 additions.

55
that 2D values are bounded in magnitude by M 2 and 3D values by M 3 (we
may need to multiply M by a constant factor).
It turns out that computations made of +, −, × and in which all d-
dimensional values are bounded in magnitude by M d have good precision
guarantees. In fact, we can prove that the absolute error of a d-dimensional
number computed in n operations is at most M d ((1 + )n − 1), which as-
suming n  1 is about nM d .
The proof is similar in spirit to what we did with only + and − earlier.
Since it is a bit long, we will not detail it here, but it can be found in
section B.1, along with a more precise definition of the precision guarantees
and its underlying assumptions.
Note that this does not cover multiplication by an adimensional factor
bigger than 1: this makes sense, since for example successive multiplication
by 2 of a small value could make the absolute error grow out of control even
if the magnitude remains under M d for a while.
In other cases, this formula nM d  gives us a quick and reliable way to
estimate precision errors.

5.3.5 Why other operations do not work as well

Now that we have precision guarantees for +, −, × operations, one might

be tempted to try and include division as well. However, if that was pos-
sible, then it would be possible to give strong precision guarantees for line
intersection, and we saw in subsection 5.1.1 that this is not the case.
The core of the problem is: if some value x is very close to zero, then
a small absolute error on x will create a large absolute error on 1/x. In
fact, if x is smaller than its absolute error, the computed value 1/x might
be arbitrarily big, both in the positive or negative direction, and might not
exist. This is why it is hard to give guarantees on the results of a division
whose operands are already imprecise.
√
An operation that also has some problematic behavior is x. If x is
√
smaller than its absolute error, then x might or might not be defined in
the reals. However, if we ignore the issue of existence by assuming that
the theoretical and actual value of x are both nonnegative, then we can say
some things on the precision.
√
Because x is a concave increasing function, a small imprecision on x
√
will have the most impact on x near 0.

56
 √ √
x x

δ x x
δ
close to 0 ⇒ big effect far from 0 ⇒ small effect
√
√ a given imprecision δ, the biggest imprecision on x it
Therefore for
might cause is δ. This is usually pretty bad: if the argument of the square
root had an imprecision of nM 2  then in the worst case the result will have
√ √
an imprecision of nM , instead of the nM  bound that we have for
+, −, × operations.
For example let us consider a circle C of radius tangent to a line l. If C
gets closer to l by 10−6 , then the intersection points will move by about
p √
12 − (1 − 10−6 )2 ≈ 2 × 10−6 = 2 × 10−3
p

away from the tangency point, as pictured below.

l C l C

√
Note that here we have only shown that 1/x and x perform poorly on
imprecise inputs. Please bear in mind that on exact inputs, the IEEE 754
guarantees that the result is the closest represented floating-point number.
So when the lines and circles are defined by integers, line intersections and
circle-line intersections have a relative precision error proportional to  and
thus an absolute error proportional to M .

5.4 Case studies

In this section, we explore some practical cases in which the imprecisions of
floating-point numbers can cause problems and give some possible solutions.

5.4.1 Problem “Keeping the Dogs Apart”

We will first talk about problem “Keeping the Dogs Apart”, which we
mentioned before, because it is a good example of accumulation of error

57
and how to deal with it. It was written by Markus Fanebust Dregi for
NCPC 2016. You can read the full statement and submit it at https:
//open.kattis.com/problems/dogs.

Here is a summarized problem statement: There are two dogs A and

B, walking at the same speed along different polylines A0 . . . An−1 and
B0 . . . Bm−1 , made of 2D integer points with coordinates in [0, 104 ]. They
start at the same time from A0 and B0 respectively. What is the closest dis-
tance they will ever be from each other before one of them reaches the end of
its polyline? The relative/absolute error tolerance is 10−4 , and n, m ≤ 105 .
The idea of the solution is to divide the time into intervals where both
dogs stay on a single segment of their polyline. Then the problem reduces
to the simpler task of finding the closest distance that get when one walks
on [P Q] and the other on [RS], with |P Q| = |RS|. This division into time
intervals can be done with the two-pointers technique: if we remember for
each dog how many segments it has completely walked and their combined
length, we can work out when is the next time on of the dogs will switch
segments.
The main part of the code looks like this. We assume that moveBy(a
,b,t) gives the point on a segment [AB] at a certain distance t from A,
while minDist(p,q,r,s) gives the minimum distance described above for
P, Q, R, S.
int i = 0, j = 0; // current segment of A and B
double ans = abs(a[0]-b[0]), // closest distance so far
sumA = 0, // total length of segments fully walked by A
sumB = 0; // total length of segments fully walked by B

// While both dogs are still walking

while (i+1 < n && j+1 < m) {
double start = max(sumA, sumB), // start of time interval
dA = abs(a[i+1]-a[i]), // length of current segment of
A
dB = abs(b[j+1]-b[j]), // length of current segment of
B
endA = sumA + dA, // time at which A will end this
segment
endB = sumB + dB, // time at which B will end this
segment
end = min(endA, endB); // end of time interval

// Compute start and end positions of both dogs

pt p = moveBy(a[i], a[i+1], start-sumA),
q = moveBy(a[i], a[i+1], end-sumA),

58
 r = moveBy(b[j], b[j+1], start-sumB),
s = moveBy(b[j], b[j+1], end-sumB);

// Compute closest distance for this time interval

ans = min(ans, minDist(p,q,r,s));

// We get to the end of the segment for one dog or the other,
// so move to the next and update the sum of lengths
if (endA < endB) {
i++;
sumA += dA;
} else {
j++;
sumB += dB;
}
}
// output ans

As we said in section 5.1.2, the sums sumA and sumB accumulate

√ very
large errors. Indeed, they can both theoretically reach M = 2 × 10 , and 9

are based on up to k = 105 additions. With double,  = 2−53 , so we could

reach up to kM  ≈ 0.016 in absolute error in both sumA and sumB. Since
this error directly translates into errors in P, Q, R, S and is bigger than the
tolerance of 10−4 , this causes WA.
In the rest of this section, we will look at two ways we can avoid this
large accumulation of error in sumA and sumB. Since this is currently much
bigger than what could have been caused by the initial length computations,
moveBy() and minDist(), we will consider those errors to be negligible for
the rest of the discussion.

Limiting the magnitude involved

The first way we can limit the accumulation of error in sumA and sumB is to
realize that in fact, we only care about the difference between them: if we
add a certain constant to both variables, this doesn’t change the value of
start-sumA, end-sumA, start-sumB or end-sumB, so the value of p, q, r, s is
unchanged.
So we can adapt the code by adding these lines at the end of the while
loop:
double minSum = min(sumA, sumB);
sumA -= minSum;
sumB -= minSum;

59
 After this, one of sumA and sumB becomes zero, while the other carries
the error on both. In total, at most n + m additions and n + m subtractions
are performed on them, for a total of k ≤ 4 × 105 . But since the difference
between
√ sumA and sumB never exceeds the length of one segment, that is,
M = 2 × 104 , the error is much lower than before:

√ 
kM  = 4 × 105 × 2 × 104 × 2−53 ≈ 6.3 × 10−7

so it gives an AC verdict.
So here we managed to reduce the precision mistakes on our results by
reducing the magnitude of the numbers that we manipulate. Of course, this
is only possible if the problem allows it.

Summing positive numbers more precisely

Now we present different way to reduce the precision mistake, based on the
fact that all the terms in the sum we’re considering are positive. This is a
good thing, because it avoids catastrophic cancellation (see section 5.3.1).
In fact, addition of nonnegative numbers conserves relative precision: if
you sum two nonnegative numbers a and b with relative errors of ka  and kb 
respectively, the worst-case relative error on a+b is about7 (max(ka , kb )+1).
Let’s say we need to compute the sum of n nonnegative numbers a1 , . . . , an .
We suppose they are exact. If we perform the addition in the conventional
order, like this:
!


· · · (a1 + a2 ) + a3 + a4 + · · · + an

then
• a1 + a2 will have a relative error of (max(0, 0) + 1) = ;
• (a1 + a2 ) + a3 will have a relative error of (max(1, 0) + 1) = 2;


• (a1 + a2 ) + a3 + a4 will have a relative error of (max(2, 0) + 1) = 3;
• . . . and so on.
So the complete sum will have an error of (n − 1), not better than what we
had before.
But what if we computed the additions in another order? For example,
with n = 8, we could do this:



(a1 + a2 ) + (a3 + a4 ) + (a5 + a6 ) + (a7 + a8 )
7
It could in fact go up to (max(ka , kb )(1 + ) + 1) but the difference is negligible for
our purposes.

60
then all additions of two numbers have error , all additions of 4 num-
bers have error (max(1, 1) + 1) = 2, and the complete addition has error
(max(2, 2) + 1) = 3, which is much better than (n − 1) = 7. In general,
for n = 2k , we can reach a relative precision of k.
We can use this grouping technique to create an accumulator such that
the relative error after adding n numbers is at most 2 log2 (n).8 Here is an
O(n) implementation:
struct stableSum {
int cnt = 0;
vector<double> v, pref{0};
void operator+=(double a) {
assert(a >= 0);
int s = ++cnt;
while (s % 2 == 0) {
a += v.back();
v.pop_back(), pref.pop_back();
s /= 2;
}
v.push_back(a);
pref.push_back(pref.back() + a);
}
double val() {return pref.back();}
};

Let’s break this code down. This structure provides two methods: add(
a) to add a number a to the sum, and val() to get the current value of the
sum. Array v contains the segment sums that currently form the complete
sum, similar to Fenwick trees: for example, if we have added 11 elements, v
would contain three elements:

v = {a1 + · · · + a8 , a9 + a10 , a11 }

while pref contains the prefix sums of v: pref[i] contains the sum of the i
first elements of v.
Function add() performs the grouping: when adding a new element a, it
will merge it with the last element of v while they contain the same number
of terms, then a is added to the end of v. For example, if we add the 12th
8
We could even get (log2 n+1) but we don’t know a way to do it faster than O(n log n).

61
element a12 , the following steps will happen:

v = {a1 + · · · + a8 , a9 + a10 , a11 } a = a12

v = {a1 + · · · + a8 , a9 + a10 } a = (a11 ) + a12
v = {a1 + · · · + a8 } a = (a9 + a10 ) + a11 + a12
v = {a1 + · · · + a8 , a9 + a10 + a11 + a12 }

The number of additions we have to make for the ith number is the
number of times it is divisible by 2. Since we only add one element to v
when adding an element to the sum, this is amortized constant time.
By simply changing the types of sumA and sumB to stableSum and adding
.val() whenever the value is read in the initial code, we can get down to an
error of about

 √ 
2 log2 105 M  = 2 log2 105 × 2 × 109 × 2−53 ≈ 5.2 × 10−6

which also gives an AC verdict.9

This is not as good as the precision obtained with the previous method,
but that method was specific to the problem, while this one can be applied
whenever we need to compute sums of nonnegative numbers.

5.4.2 Quadratic equation

As another example, we will study the precision problems that can occur
when computing the roots of an equation of the type ax2 + bx + c = 0 with
a 6= 0. We will see how some precision problems are unavoidable, while
others can be circumvented by
When working with full-precision reals, we can solve quadratic equations
in the following way. First we compute the discriminant ∆ = b2 − 4ac. If
∆ < 0, there is no solution, while if ∆ ≥ 0 there is are 1 or 2 solutions, given
by √
−b ± ∆
x=
2a
The first difficulty when working with floating-point numbers is the com-
putation of ∆: if ∆ ≈ 0, that is b2 ≈ 4ac, then the imprecisions can change
the sign of ∆, therefore changing the number of solutions.
Even if that does not happen, since we have to perform a square root,
the problems that we illustrated with line-circle intersection in section 5.3.5
can also happen here.10 Take the example of equation x2 − 2x + 1 = 0,
9
Theoretically we can’t really be sure though, since both sumA and sumB could have that
error, and we still have to take into account the other operations performed.
10
Which is not surprising, since the bottom of a parabola looks a lot like a circle.

62
which is a single root x = 0. If there is a small error on c, it can translate
into a large error on the roots. For example, if c = 1 − 10−6 , then the roots
become
√ p √
−b ± b2 − 4ac 2 ± 4 − 4(1 − 10−6 ) 2 ± 2 10−6
x= = = = 1 ± 10−3 .
2a 2 2
where the error 10−3 is much bigger than the initial error on c.

x2 − 2x + (1 + ) = 0 x2 − 2x + 1 = 0 x2 − 2x + (1 − ) = 0
√
no solution x=1 x=1± 

√
Even if the √ computation of ∆ is very precise, a second problem can
occur. If b and ∆ have a similar magnitude, in other words when b2  ac,
then catastrophic cancellation will occur for one of the roots. For example
if a = 1, b = 104 , c = 1, then the roots will be:
√ √
−104 − 108 − 4 −104 + 108 − 4
x1 = ≈ −10 4
x2 = ≈ 10−4
2 2
√
The computation of x1 goes fine because √ −b and − ∆ have the same
sign. But because the√magnitude of −b + ∆ is 108 times smaller than the
magnitude of b and ∆, the relative √ error on x2 will be 108 times bigger
than the relative error on b and ∆.
Fortunately, in this case we can avoid catastrophic cancellation entirely
by rearranging the expression:
√ √ √
−b ± b2 − 4ac −b ± b2 − 4ac −b ∓ b2 − 4ac
= × √
2a 2a −b ∓ b2 − 4ac
√ 2
(−b2 ) − b2 − 4ac
=  √ 
2a −b ∓ b2 − 4ac
4ac
=  √ 
2a −b ∓ b2 − 4ac
2c
= √
−b ∓ b2 − 4ac
In this new expression, since the sign of the operation is opposite from the
sign in the original expression, catastrophic cancellation happens in only one
of the two.

63
 √
−b− ∆ 2c√
So if b ≥ 0, we can use 2a for the first solution and −b− ∆
for
2c√
the second solution, while if b ≤ 0, we can use −b+ ∆
for the first solution
√
and −b+
2a
∆
for the second solution. We only need to be careful that the
denominator is never zero.
This gives a safer way to find the roots of a quadratic equation. This
function returns the number of solutions, and places them in out in no
particular order.
int quadRoots(double a, double b, double c, pair<double,double> &out
) {
assert(a != 0);
double disc = b*b - 4*a*c;
if (disc < 0) return 0;
double sum = (b >= 0) ? -b-sqrt(disc) : -b+sqrt(disc);
out = {sum/(2*a), sum == 0 ? 0 : (2*c)/sum};
return 1 + (disc > 0);
}

In many cases, there are several ways to write an expression, and they
can have very different behaviors when used with floating-point numbers. So
if you realize that the expression you are using can cause precision problems
in some cases, it can be a good idea to rearrange the expression to handle
them, as we did here.

5.4.3 Circle-circle intersection

This last case study will study one possible implementation for the inter-
section of two circles. It will show us why we shouldn’t rely too much on
mathematical truths when building our programs.
We want to know whether two circles of centers C1 , C2 and radii r1 , r2
touch, and if they do what are the intersection points. Here, we will solve
this problem with triangle inequalities and the cosine rule.11 Let d = |C1 C2 |.
The question of whether the circles touch is equivalent to the question
of whether there exists a (possibly degenerate) triangle with edge lengths
d, r1 , r2 .
11
The way we actually implement it in this book is completely different.

64
 r1 r2
α
C1 C2
d

We know that such a triangle exists iff the triangle inequalities are re-
spected, that is:
|r2 − r1 | ≤ d ≤ r1 + r2
If this is true, then we can find the angle at C1 , which we’ll call α, thanks
to the cosine rule:
d2 + r12 − r22
cos α =
2dr1
Once we have α, we can find the intersection points in the following way:
# »
if we take vector C1 C2 , resize it to have length r1 , then rotate by α in either
direction, this gives the vectors from C1 to either intersection points.

C1 C2 C1 C2 C1 C2

resized rotated right rotated left

This gives the following code. It uses a function abs() to compute the
length of a vector (see section 6.1.2) and a function rot() to rotate a vector
by a given angle (see section 6.2.3).
bool circleCircle(pt c1, double r1, pt c2, double r2, pair<pt,pt> &
out) {
double d = abs(c2-c1);
if (d < abs(r2-r1) || d > r1+r2) // triangle inequalities
return false;
double alpha = acos((d*d + r1*r1 - r2*r2)/(2*d*r1));
pt rad = (c2-c1)/d*r1; // vector C1C2 resized to have length d
out = {c1 + rot(rad, -alpha), c1 + rot(rad, alpha)};
return true;
}

65
 This implementation is quite nice, but unfortunately it will sometimes
output nan values. In particular, if

r1 = 0.625 r2 = 0.3750000000000004 d = 1.0000000000000004

then the triangle inequalities are respected, so the function returns true,
but the program computes

d2 + r12 − r22
>1
2dr1

In fact, this is mathematically impossible! The cosine rule should give

values in [−1, 1] as long as the edge lengths respect the triangle inequality.
To make sure, we can compute:

d2 + r12 − r22
> 1 ⇒ d2 + r12 − r22 > 2dr1
2dr1
⇔ (d − r1 )2 > r22
⇔ |d − r1 | > r2
⇔ d > r2 + r1 or r1 > d + r2

Indeed, both are impossible because of the triangle inequalities. So this

must be the result of a few unfortunate roundings made while computing
the expression.
There are two possible solutions to this. The first solution would be to
just treat the symptoms: make sure the cosine is never outside [−1, 1] by
either returning false or by moving it inside:
double co = (d*d + r1*r1 - r2*r2)/(2*d*r1);
if (abs(co) > 1) {
return false; // option 1
co /= abs(co); // option 2
}
double alpha = cos(co);

The second solution, which we recommend, is based on the principles

that we should always try to minimize the number of comparisons we make,
and that if we have to do some computation that might fail (giving a result of
nan or infinity), then we should test the input of that computation directly.

So instead of testing the triangle inequalities, we test the value of cos α

directly, because it turns out that it will be in [−1, 1] iff the triangle inequal-
ities are verified. This gives the following code, which is a bit simpler and
safer.

66
bool circleCircle(pt c1, double r1, pt c2, double r2, pair<pt,pt> &
out) {
double d = abs(c2-c1), co = (d*d + r1*r1 - r2*r2)/(2*d*r1);
if (abs(co) > 1) return false;
double alpha = acos(co);
pt rad = (c2-c1)/d*r1; // vector C1C2 resized to have length d
out = {c1 + rot(rad, -alpha), c1 + rot(rad, alpha)};
return true;
}

5.5 Some advice

In this last section, we present some general advice about precision issues
when solving or setting a problem.

5.5.1 For problem solvers

One of the keys to success in geometry problems is to develop a reliable

implementation methodology as you practise. Here are some basics to get
you started.
As you have seen in this chapter, using floating-point numbers can cause
many problems and betray you in countless ways. Therefore the first and
most important piece of advice is to avoid using them altogether. Surpris-
ingly many geometric computations can be done with integers, and you
should always aim to perform important comparisons with integers, by first
figuring out the formula on paper and then implementing it without division
or square root.
When you are forced to use floating-point numbers, you should minimize
the risks you take. Indeed, thinking about everything that could go wrong
in an algorithm is very hard and tedious, so if you take many inconsiderate
risks, the time you will need to spend too much time on verification (or not
spend it and suffer the consequences). In particular:
• Minimize the number of dangerous operations you make, such as divi-
sions, square roots, and trigonometric functions. Some of these func-
tions can amplify precision mistakes, and many are defined on re-
stricted domains. Make sure you do not go out of the domains by
considering every single one of them carefully.
• Separate cases sparingly. Many geometry problems require some case-
work, making comparisons to separate them can be unsafe, and every

67
 case adds more code and more reasons for failures. When possible, try
to write code that handles many situations at once.
• Do not rely too much on mathematical truths. Things that are true for
reals are not necessarily true for floating-point numbers. For example,
r2 − d2 and (r + d)(r − d) are not always exactly the same value. Be
extra careful when those values are then used in an operation that is
√
not defined everywhere (like x, arccos(x), tan(x), xy etc.).
In general, try to build programs that are resistant to the oddities of
floating-point numbers. Imagine that some evil demon is slightly modifying
every result you compute in the way that is most likely to make your program
fail. And try to write clean code that is clearly correct at first glance. If you
need long explanations to justify why your program will not fail, then it is
more likely that your program will in fact fail.

5.5.2 For problem setters

Finally, here is some general advice about precision issues when creating a
geometry problem and its datasets.
• Never use floating-point numbers as inputs, as this will already cause
imprecisions when first reading the input numbers, and completely
exclude the use of integers make it impossible to determine some things
with certainty, like whether two segmentns touch, whether some points
are collinear, etc.
• Make the magnitude of the input coordinates as small as possible to
avoid causing overflows or big imprecisions in the contestant’s codes.
• Favor problems where the important comparisons can be made entirely
with integers.
• Avoid situations in which imprecise points are used for numerically
unstable operations such as finding the intersection of two lines.
• In most cases, you should specify the tolerance in terms of absolute
error only (see subsection 5.3.1).
• Make sure to prove that all correct algorithm are able to reach the
precision that you require, and be careful about operations like circle-
line intersection which can greatly amplify imprecisions. Since error
analysis is more complicated than it seems at first sight and requires
a bit of expertise, you may want to ask a friend for a second opinion.

68
Chapter 6

Basics

6.1 Points and vectors

In this section, we will first introduce complex numbers, because they are a
useful way to think about and represent 2D points, especially when rotations
are involved. We will then present two different ways to represent points
in code: one by creating our own structure, the other by using the C++
built-in complex type. Either can be used to run the code samples in this
book, though complex requires less typing.

6.1.1 Complex numbers

Complex numbers are an extension of the real numbers with a new unit,
the imaginary unit, noted i. A complex number is usually written as a + bi
(for a, b ∈ R) and we can interpret it geometrically as point (a, b) in the
two-dimensional plane, or as a vector with components #» v = (a, b). We
will sometimes use all these notations interchangeably. The set of complex
numbers is written as C.

3i 5 + 3i
3)
(5,
#»v =

69
Basic operations

Complex numbers are added, subtracted and multiplied by scalars as if i

were an unknown variable. Those operations are equivalent to the same
operations on vectors.

(a + bi) + (c + di) = (a + c) + (b + d)i (addition)

(a + bi) − (c + di) = (a − c) + (b − d)i (subtraction)
k(a + bi) = (ka) + (kb)i (multiplication by scalar)

Geometrically, adding or subtracting two complex numbers #» v = (a, b) and

#» #»
w = (c, d) corresponds to making w or its opposite start at the end of
#»
v , while multiplying #»
v by a positive real k corresponds to multiplying its
length by k but keeping the same direction.

#»w #» v#»−
w w#»
#»v + #»
#»
w w

#» #»
v
v
v#»−
w#»
addition subtraction

#»
v
#»
v
#»
2v

multiplication by scalar

Polar form

The polar form is another way to represent complex numbers. To denote

a complex #»v = a + bi, instead of looking at the real and complex parts,
we look at the absolute value r, the distance from the origin (the length of
vector #»
v ), and the argument ϕ, the amplitude of the angle that #» v forms
with the positive real axis.

70
 (r sin ϕ)i b2 a + bi
√ a2 +
r= ϕ

r cos ϕ

For a given complex number a + bi, we can compute its polar form as
p
r = |a + bi| = a2 + b2
ϕ = arg(a + bi) = atan2(b, a)

and conversely, a complex number with polar coordinates r, ϕ can be written

r cos ϕ + (r sin ϕ)i = r(cos ϕ + i sin ϕ) =: r cis ϕ

where cis ϕ = cos ϕ + i sin ϕ is the unit vector that forms an angle of ampli-
tude ϕ with the positive real axis.
Note that this is not a one-to-one mapping. Firstly, adding or subtracting
2π from ϕ doesn’t change the point being represented; to solve this problem,
ϕ is generally taken in (−π, π]. Secondly, when r = 0, all values of ϕ
represent the same point.

Multiplication

Complex multiplication is easiest to understand using the polar form. When

multiplying two complex numbers, their absolute values are multiplies, while
their arguments are added. In other words,

(r1 cis ϕ1 ) ∗ (r2 cis ϕ2 ) = (r1 r2 ) cis(ϕ1 + ϕ2 ).

In the illustration below, | #» #» = | #»

v ∗ w| #» and the angle between the
v || w|
#»
x-axis and v is the same as the angle between w #» and #» #»
v ∗ w.

v#»
∗ w#» #»
w #»
v

71
 Remarkably, multiplication is also very simple to compute from the co-
ordinates: it works a bit like polynomial multiplication, except that we
transform i2 into −1.

(a + bi) ∗ (c + di) = ac + a(di) + (bi)c + (bi)(di)

= ac + adi + bci + (bd)i2
= ac + (ad + bc)i + (bd)(−1)
= (ac − bd) + (ad + bc)i

Exercise 1
Prove that (r1 cis ϕ1 ) ∗ (r2 cis ϕ2 ) = (r1 r2 ) cis(ϕ1 + ϕ2 ) using this new
definition of product.

[Go to solution]

Another way to explain complex multiplication is to say that multiplying

a number by r cis ϕ will scale it by r and rotate it by ϕ counterclockwise.
For example, multiplying a number by 12 i = 12 cis π2 will divide its length by
2 and rotate it 90◦ counterclockwise.

#» #»
v
v ∗ 12 i ϕ+ π
2
ϕ

6.1.2 Point representation

In this section we explain how to implement the point structure that we will
use throughout the rest of the book. The code is only available in C++ at
the moment, but should be easy to translate in most languages.

With a custom structure

Let us first declare the basic operations: addition, subtraction, and multi-
plication/division by a scalar.
typedef double T;

72
struct pt {
T x,y;
pt operator+(pt p) {return {x+p.x, y+p.y};}
pt operator-(pt p) {return {x-p.x, y-p.y};}
pt operator*(T d) {return {x*d, y*d};}
pt operator/(T d) {return {x/d, y/d};} // only for floating-
point
};

For generality, we declare type T: the type of the the coordinates. Generally,
either double or long long (for exact computations with integers) is appro-
priate. long double can also be very useful if extra precision is required.
The cases where integers cannot be used are often quite clear (e.g. division
by scalar, rotation by arbitrary angle).
We define some comparators for convenience:
bool operator==(pt a, pt b) {return a.x == b.x && a.y == b.y;}
bool operator!=(pt a, pt b) {return !(a == b);}

Note that there is no obvious way to define a < operator on 2D points, so

we will only define it as needed.
Here are some functions linked to the absolute value:
T sq(pt p) {return p.x*p.x + p.y*p.y;}
double abs(pt p) {return sqrt(sq(p));}

The squared absolute value sq() can be used to compute and compare dis-
tances quickly and exactly if the coordinates are integers. We use double
for abs() because it will return floating-point values even for integer co-
ordinates (if you are using long double you should probably change it to
long double).

We also declare a way to print out points, for debugging purposes:

ostream& operator<<(ostream& os, pt p) {
return os << "("<< p.x << "," << p.y << ")";
}

Some example usage:

pt a{3,4}, b{2,-1};
cout << a+b << " " << a-b << "\n"; // (5,3) (1,5)
cout << a*-1 << " " << b/2 << "\n"; // (-3,-4) (1.5,2)

We also define a signum function, which will be useful for several appli-
cations. It returns -1 for negative numbers, 0 for zero, and 1 for positive
numbers.

73
template <typename T> int sgn(T x) {
return (T(0) < x) - (x < T(0));
}

With the C++ complex structure

Using the complex type in C++ can be a very practical choice in contests
such as ACM-ICPC where everything must be typed from scratch, as many
of the operations we need are already implemented and ready to use.
The code below defines a pt with similar functionality.
typedef double T;
typedef complex<T> pt;
#define x real()
#define y imag()

Warning
As with the custom structure, you should choose the appropriate
coordinate type for T. However, be warned that if you define it as
an integral type like long long, some functions which should always
return floating-point numbers (like abs() and arg()) will be truncated
to integers.

The macros x and y are shortcuts for accessing the real and imaginary
parts of a number, which are used as x- and y-coordinates:
pt p{3,-4};
cout << p.x << " " << p.y << "\n"; // 3 -4
// Can be printed out of the box
cout << p << "\n"; // (3,-4)

Note that the coordinates can’t be modified individually:

pt p{-3,2};
p.x = 1; // doesn’t compile
p = {1,2}; // correct

We can perform all the operations that we have with the custom struc-
ture and then some more. Of course, we can also use complex multiplication
and division. Note however that we can only multiply/divide by scalars of
type T (so if T is double, then int will not work).

74
pt a{3,1}, b{1,-2};
a += 2.0*b; // a = (5,-3)
cout << a*b << " " << a/-b << "\n"; // (-1,-13) (-2.2,-1.4)

There are also useful methods for dealing with polar coordinates:
pt p{4,3};
// Get the absolute value and argument of point (in [-pi,pi])
cout << abs(p) << " " << arg(p) << "\n"; // 5 0.643501
// Make a point from polar coordinates
cout << polar(2.0, -M_PI/2) << "\n"; // (1.41421,-1.41421)

Warning
The complex library provides function norm, which is mostly equivalent
to the sq that we defined earlier. However, it is not guaranteed to be
exact for double: for example, the following expression evaluates to
false.

norm(complex<double>(2.0,1.0)) == 5.0

Therefore, to be safe you should implement a separate sq() function

as for the custom structure (or you can wait use function dot() that
we will define later).

6.2 Transformations

In this section we will show how to implement three transformations of

the plane, in increasing difficulty. We will see that they all correspond to
linear transformations on complex numbers, that is, functions of the form
f (p) = a ∗ p + b for a, b, p ∈ C, and deduce a way to compute a general
transformation that combines all three.

6.2.1 Translation

To translate an object by a vector #»v , we simply need to add #»v to every

point in the object. The corresponding function is f (p) = p+ #»
v with #»
v ∈ C.

75
 #»v

The implementation is self-explanatory:

pt translate(pt v, pt p) {return p+v;}

6.2.2 Scaling

To scale an object by a certain ratio α around a center c, we need to shorten

or lengthen the vector from c to every point by a factor α, while conserving
the direction. The corresponding function is f (p) = c + α(p − c) (α is a real
here, so this is a scalar multiplication).

Again, the implementation is just a translation of the expression into

code:
pt scale(pt c, double factor, pt p) {
return c + (p-c)*factor;
}

6.2.3 Rotation

To rotate an object by a certain angle ϕ around center c, we need to rotate

the vector from c to every point by ϕ. From our study of polar coordinates in
6.1.1 we know this is equivalent to multiplying by cis ϕ, so the corresponding
function is f (p) = c + cis ϕ ∗ (p − c).

ϕ
c ϕ

76
 In particular, we will often use the (counter-clockwise) rotation centered
on the origin. We use complex multiplication to figure out the formula:

(x + yi) ∗ cis ϕ = (x + yi) ∗ (cos ϕ + i sin ϕ)

= (x cos ϕ − y sin ϕ) + (x sin ϕ + y cos ϕ)i

which gives the following implementation:

pt rot(pt p, double a) {
return {p.x*cos(a) - p.y*sin(a), p.x*sin(a) + p.y*cos(a)};
}

which if using complex can be simplified to just

pt rot(pt p, double a) {return p * polar(1.0, a);}

And among those, we will use the rotation by 90◦ quite often:

(x + yi) ∗ cis(90◦ ) = (x + yi) ∗ (cos(90◦ ) + i sin(90◦ ))

= (x + yi) ∗ i = −y + xi

It works fine with integer coordinates, which is very useful:

pt perp(pt p) {return {-p.y, p.x};}

6.2.4 General linear transformation

It is easy to check that all those transformations are of the form f (p) =
a∗p+b as claimed in the beginning of this section. In fact, all transformations
of this type can be obtained as combinations of translations, scalings and
rotations.1
Just like for real numbers, to determine a linear transformation such as
this one, we only need to know the image of two points to know the complete
function. Indeed, if we know f (p) = a ∗ p + b and f (q) = a ∗ q + b, then we
can find a as f (q)−f
q−p
(p)
, and then b as f (p) − a ∗ p.
And thus if we want to know a new point f (r) of that transformation,
we can then compute it as:

f (q) − f (p)
f (r) = f (p) + (r − p) ∗
q−p
1
Actually, if a = 1 it is just a translation, and if a 6= 1 it is the combination of a scaling
and a rotation combination from a well-chosen center.

77
 f (q)
f (r)
r
f (p)

p q

This is easy to implement using complex:

pt linearTransfo(pt p, pt q, pt r, pt fp, pt fq) {
return fp + (r-p) * (fq-fp) / (q-p);
}

Otherwise, you can use the cryptic but surprisingly short solution from
[kactl] (see the next sections for dot() and cross()):
pt linearTransfo(pt p, pt q, pt r, pt fp, pt fq) {
pt pq = q-p, num(cross(pq, fq-fp), dot(pq, fq-fp));
return fp + pt(cross(r-p, num), dot(r-p, num)) / sq(pq);
}

6.3 Products and angles

Besides complex multiplication, which is nice to have but is not useful so of-
ten, there are two products involving vectors that are of critical importance:
dot product and cross product. In this section, we’ll look at their definition,
properties and some basic use cases.

6.3.1 Dot product

The dot product #» #» of two vectors #»

v ·w v and w #» can be seen as a measure of
how similar their directions are. It is defined as
#» #» = k #»
v ·w #» cos θ
v kk wk

where k #» #» are the lengths of the vectors and θ is amplitude of the

v k and k wk
#»
angle between v and w.#»

Since cos(−θ) = cos(θ), the sign of the angle does not matter, and the
dot product is symmetric: #» #» = w
v ·w #» · #»
v.
In general we will take θ in [0, π], so that dot product is positive if
θ < π/2, negative if θ > π/2, and zero if θ = π/2, that is, if #» #» are
v and w
perpendicular.

78
 #» #»
w
w θ θ
θ
#»
v #»
v #»
w #»
v
θ < π/2 θ = π/2 θ > π/2
#»
v ·w#» = 5 #»
v ·w#» = 0 #»
v ·w#» = −5

If we fix k #» #» as above, the dot product is maximal when the

v k and k wk
vectors point in the same direction, because cos θ = cos(0) = 1, and minimal
when they point in opposite directions, because cos θ = cos(π) = −1.

Math insight
Because of the definition of cosine in right triangles, dot prod-
uct can be interpreted in an interesting way (assuming #» v 6= 0):
#» #» = k #»
v ·w v kπ #» ( #» where π #» ( w)
w) #» := k wk
#» cos θ is the signed length
v v
of the projection of w #» onto the line that contains #»
v (see examples be-
low). In particular, this means that the dot product does not change
if one of the vectors moves perpendicular to the other.

#»
w
#» )
w #»
v #»
v
π #»v ( θ
θ
#» »)
#w
w π #»v (
π #» #» π #» #»
v ( w) = 1.58 v ( w) = −1.26

Remarkably, the dot product can be computed by a very simple expres-

sion: if #» #» = (w , w ), then #»
v = (vx , vy ) and w x y
#» = v w + v w . We can
v ·w x x y y
implement it like this:
T dot(pt v, pt w) {return v.x*w.x + v.y*w.y;}

Dot product is often used for testing if two vectors are perpendicular,
since we just need to test whether #» #» = 0:
v ·w
bool isPerp(pt v, pt w) {return dot(v,w) == 0;}

It can also be used for finding the angle between two vectors, in [0, π].
Because of precision errors, we need to be careful not to call acos with a
value that is out of the allowable range [−1, 1].
double angle(pt v, pt w) {
double cosTheta = dot(v,w) / abs(v) / abs(w);
return acos(max(-1.0, min(1.0, cosTheta)));

79
}

Since C++17, this can be simplified to:

double angle(pt v, pt w) {
return acos(clamp(dot(v,w) / abs(v) / abs(w), -1.0, 1.0));
}

6.3.2 Cross product

The cross product #»

v ×w #» of two vectors #»
v and w#» can be seen as a measure
of how perpendicular they are. It is defined in 2D as
#» #» = k #»
v ×w #» sin θ
v kk wk

where k #» #» are the lengths of the vectors and θ is amplitude of the

v k and k wk
oriented angle from #» #»
v to w.
Since sin(−θ) = − sin(θ), the sign of the angle matters, the cross product
changes sign when the vectors are swapped: w #» × #»
v = − #» #» It is positive
v × w.
if w is “to the left” of v , and negative is w is “to the right” of #»
#» #» #» v.

“to the left”

#»
v

“to the right”

In general, we take θ in (−π, π], so that the dot product is positive if

0 < θ < π, negative if −π < θ < 0 and zero if θ = 0 or θ = π, that is, if #»
v
#» are aligned.
and w

#»
v
θ
#» #» θ
w v #»
w
θ
#»
v #»
w
0<θ<π θ=π −π < θ < 0
#» #» = 5
v ×w #»
v ×w#» = 0 #»
v ×w#» = −7

If we fix k #» #» as above, the cross product is maximal when the

v k and k wk
vectors are perpendicular with w #» on the left, because sin θ = sin(π/2) = 1,
and minimal when they are perpendicular with w #» on the right, because
sin θ = sin(−π/2) = −1.

80
 Math insight
Because of the definition of sine in right triangles, cross product can
also be interpreted in an interesting way (assuming v 6= 0): #» v ×w #» =
#»
k v kd #» #» #» #»
v ( w), where d #»
v ( w) = k wk sin θ is the signed distance from the
line that contains #»v , with positive values on the left side of #» v . In
particular, this means that the cross product doesn’t change if one of
the vectors moves parallel to the other.

d v#»( #»
w)

#»
v #»
v
#»
w θ
θ
#»
w

d v#»( #»
w)

d #» #» d #» #»
v ( w) = 2.69 v ( w) = −2.37

Like dot product, cross product has a very simple expression in cartesian
coordinates: if #» #» = (w , w ), then #»
v = (vx , vy ) and w x y
#» = v w − v w :
v ×w x y y x

T cross(pt v, pt w) {return v.x*w.y - v.y*w.x;}

Implementation trick
When using complex, we can implement both dot() and cross() with
this trick, which is admittedly quite cryptic, but requires less typing
and is less prone to typos:
T dot(pt v, pt w) {return (conj(v)*w).x;}
T cross(pt v, pt w) {return (conj(v)*w).y;}

Here conj() is the complex conjugate: the conjugate of a complex

number a + bi is defined as a − bi. To verify that the implementation
is correct, we can compute conj(v)*w as

(vx − vy i) ∗ (wx + wy i) = (vx wx + vy wy ) + (vx wy − vy wx )i

and see that the real and imaginary parts are indeed the dot product
and the cross product.

81
Orientation

One of the main uses of cross product is in determining the relative position
of points and other objects. For this, we define the function orient(A, B, C) =
# » # » # »
AB × AC. It is positive if C is on the left side of AB, negative on the right
# »
side, and zero if C is on the line containing AB. It is straightforward to
implement:
T orient(pt a, pt b, pt c) {return cross(b-a,c-a);}

In other words, orient(A, B, C) is positive if when going from A to B to

C we turn left, negative if we turn right, and zero if A, B, C are collinear.

C B
C
A B A
B A
C
left turn collinear right turn
orient(A, B, C) > 0 orient(A, B, C) = 0 orient(A, B, C) < 0

Its value is conserved by cyclic rotation, that is

orient(A, B, C) = orient(B, C, A) = orient(C, A, B)

while swapping any two arguments switches the sign.

As an example of use, suppose we want to check if point X lies in the
angle formed by lines AB and AC. We can follow this procedure:
1. check that orient(A, B, C) 6= 0 (otherwise the question is invalid);
2. if orient(A, B, C) < 0, swap B and C;

C B

B C
A A
orient(A, B, C) > 0 orient(A, B, C) < 0
no swap swap

3. X is in the angle iff orient(A, B, X) ≥ 0 and orient(A, C, X) ≤ 0.

82
 X X
C C C
B B B
A A X A
orient(A, B, X) ≥ 0 orient(A, B, X) < 0 orient(A, B, X) ≥ 0
orient(A, C, X) > 0 orient(A, C, X) ≤ 0 orient(A, C, X) ≤ 0
KO KO OK
bool inAngle(pt a, pt b, pt c, pt x) {
assert(orient(a,b,c) != 0);
if (orient(a,b,c) < 0) swap(b,c);
return orient(a,b,x) >= 0 && orient(a,c,x) <= 0;
}

Using orient() we can also easily compute the amplitude of an oriented

angle BAC,
\ that is, the angle that is covered if we turn from B to C around
A counterclockwise.
There are two cases: either orient(A, B, C) ≥ 0, with an angle in [0, π],
or orient(A, B, C) < 0, with an angle in (π, 2π). In the first case, we can
simply use the angle() function we create based on the dot product; in the
second case, we should take “the other side”, so 2π minus that result.

B
C

B A

A
C

orient(A, B, C) > 0 orient(A, B, C) < 0

angle() = 50◦ angle() = 80◦
orientedAngle() = 50◦ orientedAngle() = 280◦

double orientedAngle(pt a, pt b, pt c) {
if (orient(a,b,c) >= 0)
return angle(b-a, c-a);
else
return 2*M_PI - angle(b-a, c-a);
}

Yet another use case is checking if a polygon P1 · · · Pn is convex: we com-

pute the n orientations of three consecutive vertices orient(Pi , Pi+1 , Pi+2 ),

83
wrapping around from n to 1 when necessary. The polygon is convex if they
are all ≥ 0 or all ≤ 0, depending on the order in which the vertices are given.

different signs all the same sign

⇒ not convex ⇒ convex

bool isConvex(vector<pt> p) {
bool hasPos=false, hasNeg=false;
for (int i=0, n=p.size(); i<n; i++) {
int o = orient(p[i], p[(i+1)%n], p[(i+2)%n]);
if (o > 0) hasPos = true;
if (o < 0) hasNeg = true;
}
return !(hasPos && hasNeg);
}

Polar sort

Because it can determine whether a vector points to the left or right of

another, a common use of cross product is to sort vectors by direction.
This is called polar sort: points are sorted in the order that a rotating ray
emanating from the origin would touch them. Here, we will try to use cross
product to safely sort the points by their arguments in (−π, π], that is the
order that would be given by the arg() function for complex.2

v#»4
v#»5
v#»6 v#»3

v#»0
v#»1 v#»2

2
Sorting by using the arg() value would likely be a bad idea: there is no guarantee (that
I know of) that vectors which are multiples of each other will have the same argument,
because of precision issues. However, I haven’t been to find an example where it fails for
values small enough to be handled exactly with long long.

84
 In general #»
v should go before w #» when #»
v ×w #» > 0, because that means
#» #»
w is to the left of v when looking from the origin. This test works well for
directions that are sufficiently close: for example, v#»2 × v#»3 > 0. But when
they are more than 180◦ apart in the order, it stops working: for example
v#»1 × v#»5 < 0. So we first need to split the points in two halves according to
their argument:

v#»4
v#»5

v#»6

v#»3
v#»0
v#»2
v#»1

If we isolate the points with argument in (0, π] (region highlighted in

blue) from those with argument in (−π, 0], then the cross product always
gives the correct order. This gives the following algorithm:
bool half(pt p) { // true if in blue half
assert(p.x != 0 || p.y != 0); // the argument of (0,0) is
undefined
return p.y > 0 || (p.y == 0 && p.x < 0);
}
void polarSort(vector<pt> &v) {
sort(v.begin(), v.end(), [](pt v, pt w) {
return make_tuple(half(v), 0) <
make_tuple(half(w), cross(v,w));
});
}

#» is in the blue region and

Indeed, the comparator will return true if either w
#»
v is not, or if they are in the same region and #»
v ×w #» > 0.

We can extend this algorithm in three ways:

• Right now, points that are in the exact same direction are considered
equal, and thus will be sorted arbitrarily. If we want, we can use their
magnitude as a tie breaker:
void polarSort(vector<pt> &v) {
sort(v.begin(), v.end(), [](pt v, pt w) {
return make_tuple(half(v), 0, sq(v)) <
make_tuple(half(w), cross(v,w), sq(w));
});

85
 }

With this tweak, if two points are in the same direction, the point that
is further from the origin will appear later.
• We can perform a polar sort around some point O other than the
origin: we just have to subtract that point O from the vectors #» v and
#» when comparing them. This as if we translated the whole plane so
w
that O is moved to (0, 0):
void polarSortAround(pt o, vector<pt> &v) {
sort(v.begin(), v.end(), [](pt v, pt w) {
return make_tuple(half(v-o), 0)) <
make_tuple(half(w-o), cross(v-o, w-o));
});
}

• Finally, the starting angle of the ordering can be modified easily by

tweaking function half(). For example, if we want some vector #» v to
be the first angle in the polar sort, we can write:
pt v = {/* whatever you want except 0,0 */};
bool half(pt p) {
return cross(v,p) < 0 || (cross(v,p) == 0 && dot(v,p) <
0);
}

This places the blue region like this:

#»
v

6.4 Lines
In this section we will discuss how to represent lines and a wide variety of
applications.

6.4.1 Line representation

Lines are sets of points (x, y) in the plane which obey an equation of the
form ax + by = c, with at least one of a and b nonzero. a and b determine
the direction of the line, while c determines its position.

86
 2
c+
y=
+b 1
ax = c+
+ by
ax y =c
+b
ax c −1
y=
+b −2
ax c
by=
+
ax

Equation ax+by = c can be interpreted geometrically through dot prod-

uct: if we consider (a, b) as a vector, then the equation becomes (a, b) · (x, y) =
c. This vector is perpendicular to the line, which makes sense: we saw in
6.3.1 that the dot product remains constant when the second vector moves
perpendicular to the first.

(a, b)

y =c
+b
ax

The way we’ll represent lines in code is based on another interpretation.

Let’s take vector (b, −a), which is parallel to the line. Then the equation
becomes a cross product (b, −a) × (x, y) = c. Indeed, we saw in 6.3.2 that
the cross product remains constant when the second vector moves parallel
to the first.

− a)
(b,
#»v =
Q

P y =c
+b
ax

In this way, finding the equation of a line going through two points P
# »
and Q is easy: define the direction vector #»
v = (b, −a) = P Q, then find c as
#»
v × P.
struct line {
pt v; T c;
// From direction vector v and offset c

87
 line(pt v, T c) : v(v), c(c) {}
// From equation ax+by=c
line(T a, T b, T c) : v({b,-a}), c(c) {}
// From points P and Q
line(pt p, pt q) : v(q-p), c(cross(v,p)) {}

// Will be defined later:

// - these work with T = int
T side(pt p);
double dist(pt p);
line perpThrough(pt p);
bool cmpProj(pt p, pt q);
line translate(pt t);
// - these require T = double
void shiftLeft(double dist);
pt proj(pt p);
pt refl(pt p);
}

A line will always have some implicit orientation, with two sides: the
“positive side” of the line (ax + by − c > 0) is on the left of #»
v , while the
“negative side” (ax+by −c < 0) is on the right of #»
v . In our implementation,
this orientation is determined by the points that were used to create the line.
We will represent it by an arrow at the end of the line. The figure below
shows the differences that occur when creating a line as line(p,q) or line(
q,p).

“positive side” “negative side”

ax + by − c > 0 ax + by − c < 0
Q Q

P P

“negative side” “positive side”

ax + by − c < 0 ax + by − c > 0

created as line(p,q) created as line(q,p)

#» # » #» # »
v = PQ v = QP

88
6.4.2 Side and distance

One interesting operation on lines is to find the value of ax + by − c for

a given point (x, y). For line l and point P = (x, y), we will denote this
operation as
sidel (P ) := ax + by − c = #»
v × P − c.

As we saw above, it can be used to determine which side of the line a

certain point is, and sidel (P ) = 0 if and only if P is on l (we will use this
property a few times). You may notice that sideP Q (R) is actually equal to
orient(P, Q, R).

“positive side”
sidel (P ) > 0

=0
P)
e l(
sid

“negative side”
sidel (P ) < 0

T side(pt p) {return cross(v,p)-c;}

The sidel (P ) operation also gives the distance to l, up to a constant

factor: the bigger sidel (P ) is, the further from line l. In fact, we can prove
that | sidel (P )| is kvk times the distance between P and l (this should make
sense if you’ve read the “mathy insight” in section 6.3.2).

distl (A)
distl (B)

This gives an easy implementation of distance:

double dist(pt p) {return abs(side(p)) / abs(v);}

The squared distance can be useful to check if a point is within a certain

integer distance of a line, because when using integers the result is exact if
it is an integer.

89
double sqDist(pt p) {return side(p)*side(p) / (double)sq(v);}

6.4.3 Perpendicular through a point

Two lines are perpendicular if and only if their direction vectors are per-
pendicular. Let’s say we have a line l of direction vector #»v . To find a line
perpendicular to line l and which goes through a certain point P , we could
define its direction vector as perp( #» v rotated by 90◦ counter-
v ) (that is, #»
clockwise, see section 6.2.3) and then try to work out c. However, it’s simpler
to just compute it as the line from P to P + perp( #» v ).

#»
v

l P + perp( #»
v)

perp( #»
v)
P

line perpThrough(pt p) {return {p, p + perp(v)};}

6.4.4 Sorting along a line

One subtask that often needs to be done in geometry problems is, given
points on a line l, to sort them in the order they appear on the line, following
the direction of #»
v.

#»
v
4
3
2
1
0

We can use the dot product to figure out the order of two points: a point
A comes before a point B if #»
v · A < #»v · B. So we can a comparator out of
it.

90
bool cmpProj(pt p, pt q) {
return dot(v,p) < dot(v,q);
}

In fact, this comparator is more powerful than we need: it is not limited to

points on l and can compare two points by their orthogonal projection3 on l.
This should make sense if you have read the “mathy insight” in section 6.3.1.

6.4.5 Translating a line

#»
If we want to translate a line l by vector t , the direction vector #»
v remains
the same but we have to adapt c.

0
c l0
y= l
+b
#» ax
P+ t #»
t
y =c
+b
ax
P

To find its new value c0 , we can see that for some point P on l, then
#»
P + t must be on the translated line. So we have

sidel (P ) = #»
v ×P −c=0
#»
#»

sidel0 P + t = v × P + t − c0 = 0
#»

which allows us to find c0 :

#» #» #»
c0 = #»
v × (P + t ) = #»
v × P + #»
v × t = c + #»
v × t

line translate(pt t) {return {v, c + cross(v,t)};}

A closely related task is shifting line l to the left by a certain distance δ

(or to the right by −δ).

0
= c l0
+ by
ax l

y =c
δ +b
ax

3
If you don’t know what an orthogonal projection is, read section 6.4.7.

91
 This is equivalent to translating by a vector of norm δ perpendicular to
the line, which we can compute as
#»
t = (δ/k #»
v k) perp( #»
v)

so in this case c0 becomes

#»
c0 = c + #»
v × t
= c + (δ/k #»
v k)( #»
v × perp( #»
v ))
= c + (δ/k #» v k2
v k)k #»
= c + δk #»
vk

line shiftLeft(double dist) {return {v, c + dist*abs(v)};}

6.4.6 Line intersection

There is a unique intersection point between two lines l1 and l2 if and only
if v# l»1 × v# l»2 6= 0. If it exists, we will show that it is equal to

cl1 v# l»2 − cl2 v# l»1

P =
v# l»1 × v# l»2

l1

P
l2

We only show that it lies on l1 (it should be easy to see that the expression
is actually symmetric in l1 and l2 ). It suffices to see that sidel1 (P ) = 0:
 #»
cl1 vl2 − cl2 v# l»1

# »
sidel1 (P ) = vl1 × − cl1
v# l»1 × v# l»2
cl (v# l» × v# l»2 ) − cl2 (v# l»1 × v# l»1 ) − cl1 (v# l»1 × v# l»2 )
= 1 1
v# l»1 × v# l»2
−cl2 (v# l»1 × v# l»1 )
=
v# l»1 × v# l»2
=0

bool inter(line l1, line l2, pt &out) {

T d = cross(l1.v, l2.v);
if (d == 0) return false;

92
 out = (l2.v*l1.c - l1.v*l2.c) / d; // requires floating-point
coordinates
return true;
}

6.4.7 Orthogonal projection and reflection

The orthogonal projection of a point P on a line l is the point on l that is

closest to P . The reflection of point P by line l is the point on the other side
of l that is at the same distance and has the same orthogonal projection.

P
P
l
l
P0
P0
projection reflection

To compute the orthogonal projection of P , we need to move P perpen-

dicularly to l until it is on the line. In other words, we need to find the
factor k such that sidel (P + k perp( #»
v )) = 0.
We compute

sidel (P + k perp( #»
v )) = #»
v × (P + k perp( #»
v )) − c
= v × P + v × k perp( #»
#» #» v)−c
= ( #»
v × P − c) + k( #» v × perp( #»
v ))
#» 2
= side (P ) + kk v k
l

so we find k = − sidel (P )/k #»

v k2 .
pt proj(pt p) {return p - perp(v)*side(p)/sq(v);}

To find the reflection, we need to move P in the same direction but twice
the distance:
pt refl(pt p) {return p - perp(v)*2*side(p)/sq(v);}

6.4.8 Angle bisectors

An angle bisector of two (non-parallel) lines l1 and l2 is a line that forms

equal angles with l1 and l2 . We define the internal bisector lint (l1 , l2 ) as the

93
line whose direction vector points between the direction vectors of l1 and l2 ,
and the external bisector lext (l1 , l2 ) as the other one. They are shown in the
figure below.

lext (l1 , l2 )
l2
lint (l1 , l2 )

l1

An important property of bisectors is that their points are at equal dis-

tances from the original lines l1 and l2 . In fact, if we give a sign to the
distance depending on which side of the line we are on, we can say that
lint (l1 , l2 ) is the line whose points are at opposite distances from l1 and l2
while lext (l1 , l2 ) is the line whose points are at equal distances from l1 and
l2 .
For some line l can compute this signed distance as side (P )/k #» v k (in l
section 6.4.2 we used the absolute value of this to compute the distance).
So lint (l1 , l2 ) should be the line of all points for which

sidel1 (P ) sidel2 (P )
=−
kv# l»1 k kv# l»2 k

v# l»1 × P − cl1 v# l»2 × P − cl2

⇔ = −
kv# l»1 k kv# l»2 k
 #»
v# l»2
  
vl 1 cl1 cl2
⇔ + ×P − + =0
kv# l»1 k kv# l»2 k kv# l»1 k kv# l»2 k

This is exactly an expression of the form sidel (P ) = #»

v × P − c = 0 which
defines the points on a line. So it means that we have found the #» v and c
that characterize lint (l1 , l2 ):

#» v# l» v# l»
v = # »1 + # »2
kvl1 k kvl2 k
cl cl
c = # »1 + # »2
kvl1 k kvl2 k

The reasoning is very similar for lext (l1 , l2 ), the only difference being
signs. Both can be implemented as follows.

94
line intBisector(line l1, line l2, bool interior) {
assert(cross(l1.v, l2.v) != 0); // l1 and l2 cannot be parallel!
double sign = interior ? 1 : -1;
return {l2.v/abs(l2.v) + sign * l1.v/abs(l1.v),
l2.c/abs(l2.v) + sign * l1.c/abs(l1.v)};
}

6.5 Segments

In this section we will discuss how to compute intersections and distances

involving line segments.

6.5.1 Point on segment

As an introduction, let’s first see how to check if a point P lies on segment

[AB].
For this we will first define a useful subroutine inDisk() that checks if
a point P lies on the disk of diameter [AB]. We know that the points on a
disk are those which form angles ≥ 90◦ with the endpoints of a diameter.
This can easily be checked by using dot product: AP \ B ≥ 90◦ is equivalent
# » # »
P A · P B ≤ 0 (with the exception of P = A, B in which case angle AP \ B is
undefined).

A B A B

# » # » # » # »
PA·PB ≤ 0 PA·PB > 0
in disk out of disk

bool inDisk(pt a, pt b, pt p) {
return dot(a-p, b-p) <= 0;
}

95
 Math insight
# » # »
In fact, we can notice that P A · P B is equal to the power of point P
with respect to the circle of diameter [AB]: if O is the center of that
# » # »
circle and r its radius, then P A · P B = |OP |2 − r2 . This makes it
perfect for our purpose.

With this subroutine in hand, it is easy to check whether P is on segment

[AB]: this is the case if and only if P is on line AB and also on the disk
whose diameter is AB (and thus is in the part the line between A and B).

B
A

intersection of line and disk = segment

bool onSegment(pt a, pt b, pt p) {
return orient(a,b,p) == 0 && inDisk(a,b,p);
}

6.5.2 Segment-segment intersection

Finding the precise intersection between two segments [AB] and [CD] is
quite tricky: many configurations are possible and the intersection itself
might be empty, a single point or a whole segment.
To simplify things, we will separate the problem in two distinct cases:
1. Segments [AB] and [CD] intersect properly, that is, their intersection
is one single point which is not an endpoint of either segment. This is
easy to test with orient().
2. In all other cases, the intersection, if it exists, is determined by the
endpoints. If it is a single point, it must be one of A, B, C, D, and if
it is a whole segment, it will necessarily start and end with points in
A, B, C, D.
Let’s deal with the first case: there is a single proper intersection point
I. To test this, it suffices to test that A and B are on either side of line CD,
and that C and D are on either side of line AB. If the test is positive, we
find I as a weighted average of A and B.4
4
We can understand the formula as the center of gravity of point A with weight |oB | and
point B with weight |oA |, which gives us a point I on [AB] such that |IA|/|IB| = oA /oB .

96
 C
B
A D
proper intersection

bool properInter(pt a, pt b, pt c, pt d, pt &out) {

double oa = orient(c,d,a),
ob = orient(c,d,b),
oc = orient(a,b,c),
od = orient(a,b,d);
// Proper intersection exists iff opposite signs
if (oa*ob < 0 && oc*od < 0) {
out = (a*ob - b*oa) / (ob-oa);
return true;
}
return false;
}

Then to deal with the second case, we will test for every point among
A, B, C, D if it is on the other segment. If it is, we add it to a set S. Clearly,
an endpoint cannot be in the middle of the intersection segment, so S will
always contain 0, 1 or 2 distinct points, describing an empty intersection, a
single intersection point or an intersection segment.

A
B
B
A B
C D
D A
C D C
S=∅ S = {A} S = {B, C}
no intersection intersection point intersection segment

set<pt> inters(pt a, pt b, pt c, pt d) {
pt out;
if (properInter(a,b,c,d,out)) return {out};
set<pt> s;
if (onSegment(c,d,a)) s.insert(a);
if (onSegment(c,d,b)) s.insert(b);
if (onSegment(a,b,c)) s.insert(c);
if (onSegment(a,b,d)) s.insert(d);
return s;
}

97
6.5.3 Segment-point distance

To find the distance between segment [AB] and point P , there are two cases:
either the closest point to P on [AB] is strictly between A and B, or it is
one of the endpoints (A or B). The first case happens when the orthogonal
projection of P onto AB is between A and B.

P P
P

B B B
A A A
closest to A closest to projection closest to B

To check this, we can use the cmpProj() method in line.

double segPoint(pt a, pt b, pt p) {
if (a != b) {
line l(a,b);
if (l.cmpProj(a,p) && l.cmpProj(p,b)) // if closest to
projection
return l.dist(p); // output distance to
line
}
return min(abs(p-a), abs(p-b)); // otherwise distance to A or B
}

6.5.4 Segment-segment distance

We can find the distance between two segments [AB] and [CD] based on
the segment-point distance if we separate into the same two cases as for
segment-segment intersection:
1. Segments [AB] and [CD] intersect properly, in which case the distance
is of course 0.
2. In all other cases, the shortest distance between the segments is at-
tained in at least one of the endpoints, so we only need to test the four
endpoints and report the minimum.
This can be readily implemented with the functions at our disposal.
double segSeg(pt a, pt b, pt c, pt d) {
pt dummy;

98
 if (properInter(a,b,c,d,dummy))
return 0;
return min({segPoint(a,b,c), segPoint(a,b,d),
segPoint(c,d,a), segPoint(c,d,b)});
}

Some possible cases are illustrated below.

C A A
B B B D
D
A D C C
proper intersection between points between point and
line

6.6 Polygons

In this section we will discuss basic tasks on polygons: how to find their
area and two ways to detect if a point is inside or outside them.

6.6.1 Polygon area

To compute the area of a polygon, it is useful to first consider the area of a

triangle ABC.

B
θ

We know that the area of this triangle is 12 |AB||AC| sin θ, because |AC| sin θ
is the length of the height coming down from C. This looks a lot like the
definition of cross product: in fact,
1 1  # » # »
|AB||AC| sin θ = AC × AC 
2 2

Since O is the origin, it can be implemented simply like this:

99
double areaTriangle(pt a, pt b, pt c) {
return abs(cross(b-a, c-a)) / 2.0;
}

Now that we can compute the area of a triangle, the intuitive way to
find the area of a polygon would be to
1. divide the polygon into triangles;
2. add up all the areas.
However, it turns out that reliably dividing a polygon into triangles is a
difficult problem in itself. So instead we’ll add and subtract triangle areas
in a clever way. Let’s take this quadrilateral as an example:

D C

A B

Let’s take an arbitrary reference point O. Let’s consider the vertices of

ABCD in order, and for every pair of consecutive points P1 , P2 , we’ll add
# »
the area of OP1 P2 to the total if P1 P2 goes counter-clockwise around O, and
subtract it otherwise. Additions are marked in blue and subtractions in red.

We can see that this will indeed compute the area of quadrilateral
ABCD. In fact, it works for any polygon (draw a few more examples to
convince yourself).
Note that the sign (add or subtract) that we take for the area of OP1 P2
is exactly the sign that the cross product takes. If we take the origin as
reference point O, it gives this simple implementation:
double areaPolygon(vector<pt> p) {
double area = 0.0;
for (int i = 0, n = p.size(); i < n; i++) {
area += cross(p[i], p[(i+1)%n]); // wrap back to 0 if i == n
-1
}
return abs(area) / 2.0;
}

100
We have to take the absolute value in case the vertices are given in clockwise
order. In fact, testing the sign of area is a good way to know whether the
vertices are in counter-clockwise (positive) or clockwise (negative) order. It
is good practice to always put your polygons in counter-clockwise order,
by reversing the array of vertices if necessary, because some algorithms on
polygons use this property.

6.6.2 Cutting-ray test

Let’s say we want to test if a point A is inside a polygon P1 · · · Pn . Then

one way to do it is to draw an imaginary ray from A that extends to infinity,
and check how many times this ray intersects P1 · · · Pn . If the number of
intersections is odd, A is inside, and if it is even, A is outside.

A2

A1

3 inters ⇒ A1 inside 2 inters ⇒ A2 outside

However, sometimes this can go wrong if the ray touches a vertex of the
polygon, as below. The ray from A3 intersects the polygon twice, but A3
is inside. We can try to solve the issue by counting one intersection per
segment touched, which would give three intersections for A3 , but then the
ray from A4 will intersect the polygon twice even though A4 is inside.

A4

A3

So we need to be more careful in defining what counts as an intersection.

We will split the plane into two halves along the ray: the points lower than
A, and the points at least as high (blue region). We then say that a segment
[Pi Pi+1 ] crosses the ray right of A if it touches it and Pi and Pi+1 are on
opposite halves.

101
 A

Below we show for some segments whether they are considered to cross
the ray or not. We can see in the last two examples that the behavior is
different if the segment touches the ray from below or from above.

Pi+1 Pi+1

A A
Pi Pi

• touches ray: OK • touches ray: KO

• halves 6=: OK • halves 6=: OK
⇒ crossing ⇒ no crossing

Pi+1
Pi+1

A
A Pi
Pi
• touches ray: OK
• touches ray: OK
• halves 6=: KO
• halves 6=: OK
⇒ no crossing
⇒ crossing

Exercise 2
Verify that, with this new definition of crossing, A3 and A4 are cor-
rectly detected to be inside the polygon.

Checking the halves to which the points belong is easy, but checking that
the segment touches the ray is a bit more tricky. We could check whether
the segments [Pi , Pi+1 ] and [AB] intersect for B very far on the ray, but
it actually we can do it more simply using orient: if Pi is below and Pi+1
above, then orient(A, Pi , Pi+1 ) should be positive, and otherwise it should
be negative. We can then implement this with the code below:
// true if P at least as high as A (blue part)
bool half(pt a, pt p) {
return p.y >= a.y;
}

102
// check if [PQ] crosses ray from A
bool crossesRay(pt a, pt p, pt q) {
return (half(q) - half(p)) * orient(a,p,q) > 0;
}

If we now return to the original problem, we still have to check whether

A is on the boundary of the polygon. We can do that by using onSegment()
defined in 6.5.1.
// if strict, returns false when A is on the boundary
bool inPolygon(vector<pt> p, pt a, bool strict = true) {
int numCrossings = 0;
for (int i = 0, n = p.size(); i < n; i++) {
if (onSegment(p[i], p[(i+1)%n], a))
return !strict;
numCrossings += crossesRay(a, p[i], p[(i+1)%n]);
}
return numCrossings & 1; // inside if odd number of crossings
}

6.6.3 Winding number

Another way to test if A is inside polygon P1 · · · Pn is to think of a string

with one end attached at A and the other following the boundary of the
polygon, doing one turn. If between the start position and the end position
the string has done a full turn, then we are inside the polygon. If however
the direction string has simply oscillated around the same position, then we
are outside the polygon. Another way to test it is to place one finger on
point A while another one follows the boundary of the polygon, and see if
the fingers are twisted at the end.
This idea can be generalized to the winding number. The winding num-
ber of a closed curve around a point is the number of times this curve turns
counterclockwise around the point. Here is an example.

103
 A2
A3
A5

A4

A6
A1

Points A1 and A2 are completely out of the curve so the winding number
around them is 0 (no turn). Points A3 and A4 are inside the main loop, which
goes counterclockwise, so the winding number around them is 1. The curve
turns twice counterclockwise around A5 , so the winding number is 2. Finally
the curve goes clockwise around A6 , for a winding number of −1.

Math insight
In fact, we can move the curve continuously without changing the
winding number as long as we don’t touch the reference point. There-
fore we can “untie” loops which don’t contain the point. That’s why,
when looking at A3 or A4 , we can completely ignore the loops that
contain A5 and A6 .

Math insight
If we move the reference point while keeping the curve unchanged,
the value of the winding number will only change when it crosses
the curve. If it crosses the curve from the right (according to its
orientation), the winding number increases by 1, and if it crosses it
from the left, the winding number decreases by 1.

+1 −1

104
 Exercise 3
What value will areaPolygon() (section 6.6.1) give when applied to a
closed polyline that crosses itself, like the curve above, instead of a
simple polygon? Assume we don’t take the absolute value.

[Go to solution]

To compute the winding number, we need to keep track of the amplitude

travelled, positive if counterclockwise, and negative if clockwise. We can use
angle() from section 6.3.1 to help us.

// amplitude travelled around point A, from P to Q

double angleTravelled(pt a, pt p, pt q) {
double ampli = angle(p-a, q-a);
if (orient(a,p,q) > 0) return ampli;
else return -ampli;
}

Another way to implement it uses the arguments of points:

double angleTravelled(pt a, pt p, pt q) {
// remainder ensures the value is in [-pi,pi]
return remainder(arg(q-a) - arg(p-a), 2*M_PI);
}

Then we simply sum it all up and figure out how many turns were made:
int windingNumber(vector<pt> p, pt a) {
double ampli = 0;
for (int i = 0, n = p.size(); i < n; i++)
ampli += angleTravelled(a, p[i], p[(i+1)%n]);
return round(ampli / (2*M_PI));
}

Warning
The winding number is not defined if the reference point is on the
curve/polyline. If it is the case, this code will give arbitrary results,
and potentially (int)NAN.

Angles of integer points

While the code above works, its use of floating-point numbers makes it non
ideal, and when coordinates are integers, we can do better. We will define a

105
new way to work with angles, as a type angle. This type will also be useful
for other tasks, such as for sweep angle algorithms.
Instead of working with amplitudes directly, we will represent angles by a
point and a certain number of full turns.5 More precisely, in this case, we will
use point (x, y) and number of turns t to represent angle atan2(y, x) + 2πt.
We start by defining the new type angle. We also define a utility function
t360() which turns an angle by a full turn.
struct angle {
pt d; int t = 0; // direction and number of full turns
angle t180(); // to be defined later
angle t360() {return {d, t+1};}
};

The range of angles which have the same value for t is (−π + 2πt, π + 2πt].
We will now define a comparator between angles. The approach is the
same as what we did for the polar sort in section 6.3.2, so we will reuse the
function half() which separates the plane into two halves so that angles
within one half are easily comparable:
bool half(pt p) {
return p.y > 0 || (p.y == 0 && p.x < 0);
}

It returns true for the part highlighted in blue and false otherwise.
Thus, in practice, it allows us to separate each range (−π + 2πt, π + 2πt]
into the subranges (−π + 2πt, 2πt], for which half() returns false, and
(2πt, π + 2πt], for which half() returns true.

(2πt, π + 2πt]

(−π + 2πt, 2πt]

We can now write the comparator between angles, which is nearly iden-
tical to the one we used for polar sort, except that we first check the number
of full turns t.
bool operator<(angle a, angle b) {
return make_tuple(a.t, half(a.d), 0) <
make_tuple(b.t, half(b.d), cross(a.d,b.d));
}

5
This approach is based on an original idea in [kactl], see “Angle.h”.

106
 We also define the function t180() which turns an angle by half a turn
counterclockwise. The resulting angle has an opposite direction. To find the
number of full turns t, there are two cases:
• if half(d) is false, we are in the lower half (−π + 2πt, 2πt], and we
will move to the upper half (2πt, π + 2πt], without changing t;
• if half(d) is true, we are in the upper half (2πt, π + 2πt], and we will
move to (−π + 2π(t + 1), 2π(t + 1)], the lower half for t + 1.
angle t180() {return {d*(-1), t + half(d)};}

We will now implement the function that will allow us to compute the
winding number. Consider an angle with direction point D. Given a new
direction D0 , we would like to move the angle in such a way that if direction
D0 is to the left of D, the angle increases, and if D0 is to the right of D, the
angle decreases.

D
D
O
D0
O
D0
D0left of D
D0 right of D
⇒ increase
⇒ decrease

In other words, we want the new angle to be an angle with direction D0 ,

and such that the difference between it and the old angle is at most 180◦ .
We will use this formulation to implement the function:
angle moveTo(angle a, pt newD) {
// check that segment [DD’] doesn’t go through the origin
assert(!onSegment(a.d, newD, {0,0}));

angle b{newD, a.t};

if (a.t180() < b) // if b more than half a turn bigger
b.t--; // decrease b by a full turn
if (b.t180() < a) // if b more than half a turn smaller
b.t++; // increase b by a full turn
return b;
}

We know that b as it is first defined is less than a full turn away from a, so
the two conditions are enough to bring it within half a turn of a.
We can use this to implement a new version of windingNumber() very
simply. We start at some vertex of the polygon, move vertex to vertex while
maintaining the angle, then read the number of full turns once we come back
to it.

107
int windingNumber(vector<pt> p, pt a) {
angle a{p.back()}; // start at last vertex
for (pt d : p)
a = moveTo(a, d); // move to first vertex, second, etc.
return a.t;
}

6.7 Circles

6.7.1 Defining a circle

Circle (O, r) is the set of points at distance exactly r from a point O =

(x0 , y0 ).
We can also define it by equation

(x − x0 )2 + (y − y0 )2 = r2

or parametrically as the set of all points

(x0 + r cos θ, y0 + r sin θ)

with θ in [0, 2π), for example.

r sin θ
θ
r cos θ

6.7.2 Circumcircle

The circumcircle of a triangle ABC is the circle that passes through all
three points A, B and C.

108
 A

C
O
B

It is undefined if A, B, C are aligned, and unique otherwise. We can

compute its center O this way:
pt circumCenter(pt a, pt b, pt c) {
b = b-a, c = c-a; // consider coordinates relative to A
assert(cross(b,c) != 0); // no circumcircle if A,B,C aligned
return a + perp(b*sq(c) - c*sq(b))/cross(b,c)/2;
}

The radius can then be found by taking the distance to any of the three
points, or directly taking the length of perp(b*sq(c)- c*sq(b))/cross(b,c)
# »
/2, which represents vector AO.

Math insight
The formula can be easily interpreted as the intersection point of the
line segment bisectors of segments [AB] and [AC], when considering
coordinates relative to A. Consider the bisector of [AB]. It is per-
# »
pendicular to [AB], so its direction vector is perp(AB), and it passes
# »
through the middle point 21 AB, so its constant term (variable c in
# » # »
the line structure) is perp(AB) × 21 AB = − 12 |AB|2 . Similarly, the
# »
bisector of [AC] is defined by direction vector perp(AC) and constant
term − 21 |AC|2 . We then just plug those into the formula for line
intersection found in section 6.4.6:
# » # »
# » (− 21 |AB|2 ) perp(AC) − (− 21 |AC|2 ) perp(AB)
AO = # » # »
perp(AB) × perp(AC)
# » # »
perp(|AC|2 AB − |AB|2 AC)
= # » # »
2 AB × AC

6.7.3 Circle-line intersection

A circle (O, r) and a line l have either 0, 1, or 2 intersection points.

109
 0 intersections 1 intersection 2 intersections

Let’s assume there are two intersection points I and J. We first find the
midpoint of [IJ]. This happens to be the projection of O onto the line l,
which we will call P .

r
h

O P
d

Once we have found P , to find I and J we need to move√along the line

by a certain distance h. By the Pythagorean theorem, h = r2 − d2 where
d is the distance from O to l.
This gives the following implementation (note that we have to divide
by k v#»l k so that we move by the correct distance). It returns the number
of intersections, and places them in out. If there is only one intersection,
out.first and out.second are equal.

int circleLine(pt o, double r, line l, pair<pt,pt> &out) {

double h2 = r*r - l.sqDist(o);
if (h2 >= 0) { // the line touches the circle
pt p = l.proj(o); // point P
pt h = l.v*sqrt(h2)/abs(l.v); // vector parallel to l, of
length h
out = {p-h, p+h};
}
return 1 + sgn(h2);
}

110
6.7.4 Circle-circle intersection

Similarly to the previous section, two circles (O1 , r1 ) and (O2 , r2 ) can have
either 0, 1, 2 or an infinity of intersection points (in case the circles are
identical).

0 intersections 1 intersection

2 intersections ∞ intersections

As before, we assume there are two intersection points I and J and we

try to find the midpoint of [IJ], which we call P .

r1 r2
h

O1 O2
P

Let d = |O1 O2 |. We know from the law of cosines on O1 O2 J that

d2 + r12 − r22
cos(]O2 O1 J) =
2dr1
and since O1 P J is a right triangle,
d2 + r12 − r22
|O1 P | = r1 cos(]O2 O1 J) =
2d
which allows us to find P .
Now to find h = |P I| = |P J|,
p we apply the Pythagorean theorem on
triangle O1 P J, which gives h = r12 − |O1 P |2 .

111
 This gives the following implementation, which works in a very similar
way to the code in the previous section. It aborts if the circles are identical.
int circleCircle(pt o1, double r1, pt o2, double r2, pair<pt,pt> &
out) {
pt d=o2-o1; double d2=sq(d);
if (d2 == 0) {assert(r1 != r2); return 0;} // concentric circles
double pd = (d2 + r1*r1 - r2*r2)/2; // = |O_1P| * d
double h2 = r1*r1 - pd*pd/d2; // = hˆ2
if (h2 >= 0) {
pt p = o1 + d*pd/d2, h = perp(d)*sqrt(h2/d2);
out = {p-h, p+h};
}
return 1 + sgn(h2);
}

Math insight
Let’s check that if d 6= 0 and variable h2 in the code is nonnegative,
there are indeed 1 or 2 intersections (the opposite is clearly true: if
h2 is negative, the length h cannot exist). The value of h2 is

(d2 + r12 − r22 )2

r12 −
4d2
4d r1 − (d2 + r12 − r22 )2
2 2
=
4d2
−d − r1 − r24 + 2d2 r12 + 2d2 r22 + 2r12 r22
4 4
=
4d2
(d + r1 + r2 )(d + r1 − r2 )(d + r2 − r1 )(r1 + r2 − d)
=
4d2
Let’s assume this is nonnegative. Thus an even number of those
conditions are false:

d + r1 ≥ r2 d + r2 ≥ r1 r1 + r2 ≥ d

Since d, r1 , r2 ≥ 0, no two of those can be simultaneously false, so

they must all be true. As a consequence, the triangle inequalities are
verified for d, r1 , r2 , showing the existence of a point at distance r1
from O1 and distance r2 from O2 .

6.7.5 Tangent lines

We say that a line is tangent to a circle if the intersection between them is

a single point. In this case, the ray going from the center to the intersection

112
point is perpendicular to the line.

Here we will try and find a line which is tangent to two circles (O1 , r1 )
and (O2 , r2 ). There are two types of such tangents: outer tangents, for
which both circles are on the same side of the line, and inner tangents, for
which the circles are on either side.

outer tangents inner tangents

We will study the case of outer tangents. Our first goal is to find a unit
vector parallel to the rays [O1 P1 ] and [O2 P2 ], in other words, we want to
# »
find #»
v = O1 P1 /r1 . To do this we will try to find angle α marked on the
figure.

P1
v#»

P2
r2

h
r1 −

α
O1 d O2

If we project O2 onto the ray from O1 , this forms a right triangle with
hypothenuse d = |O1 O2 | and adjacent side r1 − r2 , which p means cos α =
r1 −r2
d . By the Pythagorean theorem, the third side is h = d2 − (r1 − r2 )2 ,
h
and we can compute sin α = d .

113
 # »  # »
From this we find #»
v in terms of O1 O2 and perp O1 O2 as
# »    # » 
#»
v = cos α O1 O2 /d ± sin α perp O1 O2 /d
# »  # »
(r1 − r2 ) O1 O2 ± h perp O1 O2
=
d2
where the ± depends on which of the two outer tangents we want to find.
We can then compute P1 and P2 as

P1 = O1 + r1 #»
v and P2 = O2 + r2 #»
v

Exercise 4
Study the case of the inner tangents and show that it corresponds
exactly to the case of the outer tangents if r2 is replaced by −r2 .
This will allow us to write a function that handles both cases at once
with an additional argument bool inner and this line:
if (inner) r2 = -r2;

This gives the following code. It returns the number of tangents of the
specified type. Besides,
• if there are 2 tangents, it fills out with two pairs of points: the pairs
of tangency points on each circle (P1 , P2 ), for each of the tangents;
• if there is 1 tangent, the circles are tangent to each other at some point
P , out just contains P 4 times, and the tangent line can be found as
line(o1,p).perpThrough(p) (see 6.4.3);
• if there are 0 tangents, it does nothing;
• if the circles are identical, it aborts.
int tangents(pt o1, double r1, pt o2, double r2, bool inner, V<pair<
pt,pt>> &out) {
if (inner) r2 = -r2;
pt d = o2-o1;
double dr = r1-r2, d2 = sq(d), h2 = d2-dr*dr;
if (d2 == 0 || h2 < 0) {assert(h2 != 0); return 0;}
for (int sign : {-1,1})
pt v = (d*dr + perp(d)*sqrt(h2)*sign)/d2;
out.pb({o1 + v*r1, o2 + v*r2})
}
return 1 + (h2 > 0);
}

114
 Conveniently, the same code can be used to find the tangent to a circle
passing through a point by setting r2 to 0 (in which case the value of inner
doesn’t matter).

115
Chapter 7

3D geometry

In this chapter we cover the basic objects and concepts of 3D geometry, and
the operations we can do on them. Although the additional dimension adds
some complexity which can make things more difficult and interesting, a
lot of things work the same way as they do in 2D. Therefore, we will make
frequent references to chapter 6, which we consider as a prerequisite.

7.1 Points, products and orientation

In this first section, we define our point representation, we explain how the
dot and cross products we saw in 2D translate into 3D, and we show how a
combination of the two, the mixed product, can help us define a 3D analog
of the orient() function.

7.1.1 Point representation

We will define points and vectors in space by their coordinates (x, y, z): their
positions along three perpendicular axes.

P = (1, 3, 2)

y
x

As we did in 2D, we start with some basic operators.

116
typedef double T;
struct p3 {
T x,y,z;

// Basic vector operations

p3 operator+(p3 p) {return {x+p.x, y+p.y, z+p.z};}
p3 operator-(p3 p) {return {x-p.x, y-p.y, z-p.z};}
p3 operator*(T d) {return {x*d, y*d, z*d};}
p3 operator/(T d) {return {x/d, y/d, z/d};} // only for floating
-point

// Some comparators
bool operator==(p3 p) {return tie(x,y,z) == tie(p.x,p.y,p.z);}
bool operator!=(p3 p) {return !operator==(p);}
};

Choosing the scalar type T is done the same way as in 2D, see 6.1.2 for our
remarks on that.
#»
For convenience, we also define a zero vector 0 = (0, 0, 0):
p3 zero{0,0,0};

7.1.2 Dot product

The dot product is exactly the same as in 2D. It is defined as

#» #» = k #»
v ·w #» cos θ
v kk wk

where k #» #» are the lengths of the vectors and θ is amplitude of the

v k and k wk
#»
angle between v and w. #» So in other words, the 3D dot product of #» v and
#»
w is equal to the 2D dot product they would have on a plane that contains
them both.
We recall the possible cases for the sign of the dot product:

#» #»
w
w θ θ
θ
#»
v #»
v #»
w #»
v
θ < π/2 θ = π/2 θ > π/2
#»
v ·w#» = 5 #»
v ·w#» = 0 #»
v ·w#» = −5

We recall some properties of dot product and add a few:

117
 • symmetry: #» v ·w #» = w
#» · #»
v;
• linearity: (v1 + v2 ) · w = v#»1 · w
#» #» #» #» + v#» · w
2
#» (also on the right);
• #» #» #» #»
v · w = 0 iff v and w are perpendicular;
• #»
v ·w#» stays constant if w #» moves perpendicular to #» v.
Like in 2D, dot product is very simple to implement:
T operator|(p3 v, p3 w) {return v.x*w.x + v.y*w.y + v.z*w.z;}

Since 3D geometry uses dot and cross product a lot, to shorten notations
we will be using operator | for dot product and operator * for cross product.
We chose them for these mostly arbitrary reasons:
• | has a lower precedence than * which is desirable, it kind of looks like
a “parallel” operator, and since it most often has to be parenthesized
(e.g. (v|w) == 0), it can be a bit reminiscent of the inner product
notation hv, wi;
• * is the closest thing to a cross in overloadable R++ operators, and
the compiler doesn’t produce a warning if you don’t paranthesize b*c
in expressions such as a|b*c, which we will use a lot.
We define the usual sq() and abs() based on dot product and add a
unit() function that makes the norm of a vector equal to 1 while preserving
its direction.
T sq(p3 v) {return v|v;}
double abs(p3 v) {return sqrt(sq(v));}
p3 unit(p3 v) {return v/abs(v);}

Like in 2D, we can also use dot product to find the amplitude in [0, π]
of the angle between vectors #» #» see secton 6.3.1 for more details.
v and w,
double angle(p3 v, p3 w) {
double cosTheta = (v|w) / abs(v) / abs(w);
return acos(max(-1.0, min(1.0, cosTheta)));
}

7.1.3 Cross product

While the cross product in 2D is a scalar, in 3D it is a vector. If #» #»

v and w
#» #» #»
are parallel, v × w = 0 , and otherwise it is defined as
#»
v ×w#» = (k #» #» sin θ) #»
v kk wk n
where k #» #» are the lengths of the vectors, θ is amplitude of the
v k and k wk
angle between #»
v and w,#» and #»
n is a unit vector perpendicular to both #»
v
#»
and w chosen using the right-hand rule. Note that the norm of the 3D cross
product is equal to the absolute value of the 2D cross product.

118
 #» #»
v ×w

#»
w
#»
v

The right-hand rule says this: if you take your right hand, align your
thumb with #» v and your extended index w, #» and fold your middle finger at
◦
a 90 angle, then it will point in the direction of #» #» Another way to
v × w.
#» #»
express it is to say that if you draw v and w on a sheet of paper and look at
the sign of their 2D cross product, if it is positive #»
v ×w#» will point up from
#» #»
the sheet, and if it is negative v × w will point down through the sheet.

#» #»
v
w #» #»
v ×w
#»
v
#» #»
v ×w #»
w
points towards you points away from you

We summarize some key properties of the cross product:

• anti-symmetry: #» v ×w #» = − w#» × #»
v;
#» #» #» #»
• linearity: (v1 + v2 ) × w = v1 × w #» + v#» × w#» (also on the right);
2
• #»
v ×w#» is perpendicular to both #» v and w;#» 1
• #»
v ×w#» is perpendicular to the plane containing #» #» 1
v and w;
#»
• #»
v ×w#» = 0 iff #»
v and w #» are perpendicular;
• #»
v ×w#» stays constant if w #» moves parallel to #» v.
Among those, the one which we will use most often is the fact that it is
perpendicular to #» #»
v and w.
The cross product can be computed this way:
p3 operator*(p3 v, p3 w) {
return {v.y*w.z - v.z*w.y,
v.z*w.x - v.x*w.z,
v.x*w.y - v.y*w.x};
}

Indeed, it is easy to check that this vector is perpendicular to both #»

v and
#» using dot product. Here it is for #»
w v:
( #» #» · #»
v × w) v = (vy wz − vz wy , vz wx − vx wz , vx wy − vy wx ) · (vx , vy , vz )
= vx vy wz − vx vz wy + vy vz wx − vy vx wz + vz vx wz − vz vy wx
=0
1
if #» #» 6= #»
v ×w 0

119
 Note that the z-coordinate is the same expression as the 2D cross prod-
uct: indeed, it is the value of the 2D cross product if #» #» are projected
v and w
onto plane z = 0.

7.1.4 Mixed product and orientation

A very useful combination of dot product and cross product is the mixed
product. We define the mixed product of three vectors #»
u , #» #» as
v and w

( #»
u × #» #»
v)·w

Let Π be the plane containing #» u and #» v . We know that #»n = #»

u × #»
v is
perpendicular to Π, and n · w will be positive if the angle between #»
#» #» n and
#» is less than 90◦ . This will happen if w
w #» points to the same side of Π as #»
n,
#» #» #»
while when n · w is negative w will point to the opposite side.
The two cases are illustrated in the drawings below. The plane contain-
ing #»
u and #»
v is viewed from the side:

#» #»
w #»
n n
#»v #»v
d d
#»u an #»u an
f f
neo ne
o #»
w
pla pla

( #»
u × #» #» > 0
v)·w ( #»
u × #» #» < 0
v)·w

Note that this is similar to how the 2D cross product #»

v ×w #» tells us to
#» #»
which side of to line containing v vector w points. So, we similarly define
an orient() function based on it:
 # » # » # »
orient(P, Q, R, S) = P Q × P R · P S

# » # »
It is positive if S is on the side of plane P QR in the direction of P Q × P R,
negative if S is on the other side, and zero if S is on the plane.

R
S R R

S P Q
P Q P Q S
S above P QR S on P QR S below P QR
orient(P, Q, R, S) > 0 orient(P, Q, R, S) = 0 orient(P, Q, R, S) < 0

120
 This orient() function has several very nice properties. First, it stays
the same if we swap any three arguments in a circular way: for exam-
ple let’s take P, Q, S, then orient(P, Q, R, S) = orient(Q, S, R, P ). On the
other hand, swapping any two arguments changes its sign: for example,
orient(P, Q, R, S) = − orient(P, S, R, Q).

Exercise 5
Show that those properties also apply to the mixed product. For
example, ( #»
u × #» #» = ( #»
v)·w #» · #»
v × w) u and ( #»
u × #» #» = −( #»
v)·w #» · #»
u × w) v.

[Go to solution]

Earlier, we implicitly assumed that P, Q, R were not collinear, but in

general orient(P, Q, R, S) is zero if and only if P, Q, R, S are coplanar, so
when any three points are collinear it is always zero. We can also say that
it is nonzero if and only if lines P Q and RS are skew, that is, neither
intersecting nor parallel.
Finally, |orient(P, Q, R, S)| is equal to six times the volume of tetrahe-
dron P QRS.
It is implemented by simply writing down the definition:
T orient(p3 p, p3 q, p3 r, p3 s) {return (q-p)*(r-p)|(s-p);}

Exercise 6
A convenient way to check whether two lines P Q and RS are skew is
# » # » # »
to check whether P Q × RS · P R 6= 0: in fact you can replace P R
by any vector going from P Q to RS.
Using the properties of dot product, cross product and orient(), prove
that  # » # » # »
P Q × RS · P R = − orient(P, Q, R, S)

[Go to solution]

Let’s say we have a plane Π and a vector #»

n perpendicular to it (a normal
# »
to the plane). Then an interesting variant is to replace P S by #»
n , giving the
expression  # » # »
P Q × P R · #»n

This is equivalent to computing the 2D orient(P 0 , Q0 , R0 ) on Π, where P 0 , Q0 , R0

are the projections of P, Q, R on Π.

121
 #» R
n #» #»
n R n
P P R
P

Q Q Q

left turn aligned right turn

 # » # »  # » # »  # » # »
P Q × P R · #»n >0 P Q × P R · #»
n =0 P Q × P R · #»n <0

T orientByNormal(p3 p, p3 q, p3 r, p3 n) {return (q-p)*(r-p)|n;}

7.2 Planes

In this section we will discuss how to represent planes, and many ways we
can use them. We will see that they play a very similar role to the role lines
play in 2D, and many of the operations we defined in section 6.4 have a
direct equivalent here. Since the explanations are nearly identical, we make
them a bit shorter here; please refer to section 6.4 if you want more details.

7.2.1 Defining planes

Planes are sets of points (x, y, z) which obey an equation of the form ax +
by + cz = d. Here, a, b, c determine the orientation of the plane, while d
determines its position relative to the origin.

ax + by + cz = d + 1

ax + by + cz = d

ax + by + cz = d − 1

Vector #»
n = (a, b, c) is perpendicular to the plane and is called a normal
of the plane. The equation can be rewritten as #» n · (x, y, z) = d: that is, the
plane is formed by all points whose dot product with #» n is equal to constant
d. This makes sense, because we know that the dot product doesn’t change
when one vector (here, the point (x, y, z)) moves perpendicularly to the
other (here, the normal #» n ).

122
 #»
n

Here are some other ways to define a plane, and how to find #»n and d in
each case:
• if we know the normal #» n and a point P belonging to the plane: we
#»
can find d as n · P ;
• if we know a point P and two (non-parallel) vectors #»
v and w#» that are
parallel to the plane: we can define #»
n = #»
v ×w#» then find d as above;
• if we know 3 non-collinear points P, Q, R on the plane: we first find
# » # »
two vectors #»
v = P Q and w#» = P R that are parallel from the plane,
#»
then find n and d as above.
We implement this with the following structure and constructors:
struct plane {
p3 n; T d;
// From normal n and offset d
plane(p3 n, T d) : n(n), d(d) {}
// From normal n and point P
plane(p3 n, p3 p) : n(n), d(n|p) {}
// From three non-collinear points P,Q,R
plane(p3 p, p3 q, p3 r) : plane((q-p)*(r-p), p) {}

// Will be defined later:

// - these work with T = int
T side(p3 p);
double dist(p3 p);
plane translate(p3 t);
// - these require T = double
plane shiftUp(double dist);
p3 proj(p3 p);
p3 refl(p3 p);
};

7.2.2 Side and distance

The first thing we are interested for a plane Π in is the value of ax+by+cz−d.
If it’s zero, the point is on Π, and otherwise it tells us which side of Π the
point lies. We name it side(), like its 2D line equivalent:

123
T side(p3 p) {return (n|p)-d;}

which we will denote sideΠ (P ).

sideΠ (P ) is positive if P is on the side of Π pointed by #»
n , and negative
for the other side. In fact, for given points P, Q, R, S, plane(p,q,r).side(s)
gives the same value as orient(p,q,r,s).

#»
n P #»
n #»
n

P
P
P above P on plane P below
sideΠ (P ) = 3 sideΠ (P ) = 0 sideΠ (P ) = −2

And just like the side() for 2D lines, we can get the distance from it, if
we compensate for the norm of #»n:
double dist(p3 p) {return abs(side(p))/abs(n);}

7.2.3 Translating a plane

#»
If we translate a plane by a vector t , the normal #»
n remains unchanged, but
the offset d changes.

#»
t

To find the new value d0 , we use the same argument as for 2D lines:
#»
suppose point P is on the old plane, that is, #»
n · P = d. Then P + t should
be in the new plane:
#» #» #»
d0 = #»
n · (P + t ) = #»
n · P + #»
n · t = d + #»
n· t

plane translate(p3 t) {return {n, d+(n|t)};}

And if we want to shift perpendicularly (in the direction of #»

n ) by some
#» #» #»
distance δ, then n · t becomes δk n k, which gives the following code:
plane shiftUp(double dist) {return {n, d + dist*abs(n)};}

124
7.2.4 Orthogonal projection and reflection

The orthogonal projection of a point P on a plane Π is the point on Π that

is closest to P . The reflection of point P by plane Π is the point on the
other side of Π that is at the same distance and has the same orthogonal
projection.

P
P

P0
P0
projection reflection

We use a similar reasoning as in section 6.4.7. Clearly, to go from P to

its projection on Π, we need to move perpendicularly to Π, that is, we need
to move by k #»
n for some k, so that the resulting point P + k #»
n is on Π.
From this we find k:
#»
n · (P + k #»
n ) = d ⇔ #»
n · P + k( #»
n · #»
n) = d
#» 2 #»
⇔ kk n k = −( n · P − d)
sideΠ (P )
⇔k=−
k #»
n k2

And to find the reflection, we need to move P twice as far to P + 2k #»

n,
so we get the following implementation for both:
p3 proj(p3 p) {return p - n*side(p)/sq(n);}
p3 refl(p3 p) {return p - n*2*side(p)/sq(n);}

7.2.5 Coordinate system based on a plane

When we have a plane Π, sometimes we will want to know what are the
coordinates of a point in Π. That is, suppose we have a few points that we
know are coplanar, and we want to use some 2D algorithm on them. How
do we get the 2D coordinates of those points?
To do this, we need to chose an origin point O on Π and two vectors
#» #» #»
dx and dy indicating the desired x and y directions. Let’s first assume dx
#»
and dy are perpendicular and their norms are 1. Then, to find the x- and

125
y-coordinate of a point P on Π, we simply need to compute
# » #»
x = OP · dx
# » #»
y = OP · dy
#» #» #»
and if we also have vector dz = dx × dy perpendicular to the first two, we
can find the “height” of P respective to Π:
# » #»
z = OP · dz

#»
dz

P
#»
#» dy
dx

If we have three non-collinear points P, Q, R that form plane Π, how can

#» #» #»
we choose dx , dy and dz ?
#» # »
1. First, we choose dx to be P Q, then scale it to have a norm of 1.
#» #» # »
2. Then we compute dz = dx × P R, wh and scaling it to have a norm of 1.
It is perpendicular to Π because it is perpendicular to two non-parallel
vectors in it.
#» #» #»
3. Finally, we find dy as dz × dx .
This gives the following code. Method pos2d() gives the position on the
plane as a 2D point, and method pos3d() gives the position and height as
a 3D point (so in a way this structure represents a change of coordinate
system).
struct coords {
p3 o, dx, dy, dz;
// From three points P,Q,R on the plane:
// build an orthonormal 3D basis
coords(p3 p, p3 q, p3 r) : o(p) {
dx = unit(q-p);
dz = unit(dx*(r-p));
dy = dz*dx;
}
// From four points P,Q,R,S:
// take directions PQ, PR, PS as is
coords(p3 p, p3 q, p3 r, p3 s) :

126
 o(p), dx(q-p), dy(r-p), dz(s-p) {}

pt pos2d(p3 p) {return {(p-o)|dx, (p-o)|dy};}

p3 pos3d(p3 p) {return {(p-o)|dx, (p-o)|dy, (p-o)|dz};}
};

Math insight
The second constructor allows us specify points P, Q, R, S and choose
#» # » #» # » #» # »
dx = P Q, dy = P R and dz = P S directly. This can be useful if we
#» #»
don’t care that the 2D coordinate system (dx , dy ) is not orthonormal
(perpendicular and of norm 1), because it allows us to keep using
integer coordinates.
#» #»
If dx and dy are not perpendicular or do not have a norm of 1, the
computed distances and angles will not be correct. But if we are only
interested in the relative positions of lines and points, and finding
the intersections of lines or segments, then everything works fine.
Computing the 2D convex hull of a set of points is an example of
such a problem, because it only requires that the sign of orient() is
correct.

7.3 Lines

In this section we will discuss how to represent lines in 3D, and some related
problems, including finding the line at the intersection of two planes, and
finding the intersection point of a plane and a line.

7.3.1 Line representation

Unlike 2D lines and planes, 3D lines don’t have a nice representation as a

single equation on coordinates like ax + by = c or ax + by + cz = d. We
could represent them as the intersection of two planes, like

a1 x + b1 y + c1 z = d1
a2 x + b2 y + c2 z = d2

but this representation is not very convenient to work with, and there are
many pairs planes we could choose.

127
 a1 x + b1 y + c1 z = d1

a2 x + b2 y + c2 z = d2

Instead, we will work with a parametric representation: we take a point

#»
O on the line and a vector d parallel to the line and say that the points
belonging to the line are all points
#»
P = O +kd
where k is a real parameter.

O
#»
d

#»
Note that here, d plays the same role as #»
v did for 2D lines (see sec-
tion 6.4.1).
If we are given two points P, Q on the line, we can set O = P and
#» # »
d = P Q, so we implement the structure like this:
struct line3d {
p3 d, o;
// From two points P, Q
line3d(p3 p, p3 q) : d(q-p), o(p) {}
// From two planes p1, p2 (requires T = double)
line3d(plane p1, plane p2); // will be implemented later

// Will be defined later:

// - these work with T = int
double sqDist(p3 p);
double dist(p3 p);
bool cmpProj(p3 p, p3 q);
// - these require T = double
p3 proj(p3 p);
p3 refl(p3 p);
p3 inter(plane p) {return o - d*p.side(o)/(d|p.n);}
};

128
7.3.2 Distance from a line
#» # »
A point P is on a line l described by O, d if and only if OP is parallel to
#» #» # » #»
d . This is the case when d × OP = 0 .

#» # »
d × OP

# »
OP
P O #»
d

#» # »
More generally, this product d × OP also gives us information about the
distance to the line: the distance from l to P is equal to
#» # »
d × OP
#»
d

double sqDist(p3 p) {return sq(d*(p-o))/sq(d);}

double dist(p3 p) {return sqrt(sqDist(p));}

7.3.3 Sorting along a line

Just like we did with 2D lines in section 6.4.4, we can sort points according
to their position along a line l. To find out if a point P should come before
another point Q, we simply need to check whether
#» #»
d ·P < d ·Q

so we can use the following comparator:

bool cmpProj(p3 p, p3 q) {return (d|p) < (d|q);}

7.3.4 Orthogonal projection and reflection

Let’s say we want to project P on a line l, that is find the closest point
to P on l. Our usual approach to projecting things, which is to move P
perpendicularly until it touches l, doesn’t work as well here: indeed, there
are many possible directions that are perpendicular to l.

129
 P P
P0
P0

O O
#» #»
d d

projection reflection

Instead we will start from O and move along the line until we reach the
projection of P . We have seen in the previous section that taking the dot
#»
product with d tells us how far some point is along l. In fact, if we compute
#» # »
d · OP , this tells us the (signed) distance from O to the projection of P ,
#»
multiplied by k d k. So we can find the projection this way:
p3 proj(p3 p) {return o + d*(d|(a-o))/sq(d);}

Once we’ve found the projection P 0 , we can find the reflection P 00 easily,
# »
since it is twice as far in the same direction: we have P 00 = P 0 + P P 0 , which
becomes 2P 0 − P if we allow vector operations on points.
p3 refl(p3 p) {return proj(p)*2 - p;}

7.3.5 Plane-line intersection

Let’s say we have a plane Π, represented by vector #»n and real d, and a line
#»
l, represented by point O and d . To find an intersection between them, we
#»
need to find a point O + k d that lies on Π, that is, such that
#»
 #»
n · O +kd = d

#»
n

O
#»
d

Solving for k, we find

d − #»
n ·O − sideΠ (O)
k= #» #» = #» #»
n·d n·d

130
which can be implemented directly:
p3 inter(plane p) {return o - d*p.side(o)/(p.n|d);}

#»
Note that this is undefined when #»
n · d = 0, that is, when Π and l are
parallel.2

7.3.6 Plane-plane intersection

If we are given two non-parallel planes Π1 and Π2 (defined by n# »1 , d1 and

n# »2 , d2 ), how can we find their common line?
#»
First we need to find its direction d . Clearly, the direction needs to be
parallel to both planes, so it must be perpendicular to both n# »1 and n# »2 . Thus
#»
we take d = n# »1 × n# »2 .
Then we need to find an arbitrary point O that is on both planes. Here,
we will actually compute the closest such point to the origin. It is given by

#»
d1 n# »2 − d2 n# »1 × d
O= #» 2
d

Let’s analyze this expression. It is the sum of two vectors,

d1  #»
v#»1 = #» 2 n# »2 × d
d
d2  #»
v#»2 = #» 2 n# »1 × d
d

Because v#»1 is perpendicular to n# »2 , it is parallel to Π2 , while v#»2 is perpendic-

ular to n# »1 and thus parallel to Π1 . So we can see v#»1 as the vector that leads
from the origin to Π1 while staying parallel to Π2 , and v#»2 as the vector that
leads from the origin to Π2 while staying parallel to Π1 .

Π2
Π1
O

v#»1 v#»2

2
We take a closer look at criteria for parallelism and perpendicularity in section 7.4.

131
 Let’s verify that O is on Π1 , that is, n# »1 · O = n# »1 · (v#»1 + v#»2 ) = d1 . Since
v2 is perpendicular to n# »1 , clearly n# »1 · v#»2 = 0. What remains is
#»

d1  #»
n# »1 · v#»1 = #» 2 n# »2 × d · n# »1
d
d1   #»
= #» 2 n# »1 × n# »2 · d
d
d1  #» #»
= #» 2 d · d
d
= d1

where between the first two lines, we used the fact that the mixed product
is conserved if we swap its arguments in a circular way (see exercise 5).
We prove similarly that O is on Π2 . Finally we note that both v#»1 and
#» #»
v2 are perpendicular to d , so the vector from the origin to O is perpencular
#»
to d , the direction of the line. Therefore it must necessarily arrive on the
line at the closest point to the origin.
We can implement this as the following constructor:
line3d(plane p1, plane p2) {
d = p1.n*p2.n;
o = (p2.n*p1.d - p1.n*p2.d)*d/sq(d);
}

7.3.7 Line-line distance and nearest points

#» #»
Consider line l1 defined by O1 + k d1 and line l2 defined by O2 + k d2 . If they
are parallel, the distance between them is easy to find: just find the distance
from l1 to O2 . Otherwise, they are either intersecting or skew, in which case
the question is a bit more complex.

parallel intersecting skew

Let’s call C1 the point of l1 that is closest to l2 , and C2 the point on l2

# »
that is closest to l1 . Direction C1 C2 should be perpendicular to both l1 and

132
l2 . Indeed, if it were not, it would be possible to get a smaller distance by
# »
moving either C1 or C2 . So C1 C2 is parallel to #»n = v#»1 × v#»2 .

l2

#»
d2
l1

C2
#»
n
C1

#»
d1

Because of this, we could compute the distance as

 # » #»
C1 C2 · n 
|C1 C2 | =
k #»
nk

We don’t know C1 or C2 yet, but since the dot product doesn’t change when
one of the vectors moves perpendicular to the other, we can move C1 to O1
and C2 to O2 , so that we get
 # » #»  # » #»  # » #»
C1 C2 · n  O1 C2 · n  O1 O2 · n 
#» = #» =
knk knk k #»
nk

which gives the following implementation:

double dist(line l1, line l2) {
p3 n = l1.d*l2.d;
if (n == zero) // parallel
return l1.dist(l2.o);
return abs((l2.o-l1.o)|n)/abs(n);
}

Now, how can we find C1 and C2 themselves? Let’s call Π2 the plane
#»
that contains l2 and is parallel to n2 ; its normal is n# »2 = d2 × #»
n . Then C1 is
the intersection between that plane and line l1 , so we can use the formula
obtained in section 7.3.5 to find it:
# »
O1 O2 · n# »2
C1 = O1 + #» # »
d1 · n2

133
 l2

#»
d2
Π2
C2
#»
n
C1
l1 n# »2

This is implemented in a straightforward way. If we want C2 instead we

just have to swap l1 and l2 .
p3 closestOnL1(line l1, line l2) {
p3 n2 = l2.d*(l1.d*l2.d);
return l1.o + l1.d*((l2.o-l1.o)|n2)/(l1.d|n2);
}

7.4 Angles between planes and lines

In this section, we figure out how to check whether lines and planes are
parallel or perpendicular, and then how to find the line perpendicular to a
plane going through a given point, and vice versa. All those operations are
very easy with our representation of planes and lines.

7.4.1 Between two planes

The angle between two planes is equal to the angle between their normals.
Since usually two angles of distinct amplitudes θ and π − θ are formed, we
take the smaller of the two, in [0, π2 ].

n# »2
n# »1 # »
n2
θ
π−θ

We can find it with the following code. We take the minimum with 1 to
avoid nan in case of imprecisions.

134
double smallAngle(p3 v, p3 w) {
return acos(min(abs(v|w)/abs(v)/abs(w), 1.0));
}
double angle(plane p1, plane p2) {
return smallAngle(p1.n, p2.n);
}

In particular, we can check whether two planes are parallel/perpendicu-

lar by checking if their normals are parallel/perpendicular:
bool isParallel(plane p1, plane p2) {
return p1.n*p2.n == zero;
}
bool isPerpendicular(plane p1, plane p2) {
return (p1.n|p2.n) == 0;
}

7.4.2 Between two lines

The situation with lines is exactly the same: their angle is equal to the angle
between their direction vectors. Note that the lines aren’t necessarily in the
same plane, so the angle is taken as if they were moved until they touch.

θ
#» #»
d1 d2
π−θ

double angle(line3d l1, line3d l2) {

return smallAngle(l1.p, l2.d);
}
bool isParallel(line3d l1, line3d l2) {
return l1.d*l2.d == zero;
}
bool isPerpendicular(line3d l1, line3d l2) {
return (l1.d|l2.d) == 0;
}

135
7.4.3 Between a plane and a line

The situation when considering a plane and a line is a bit different. Let’s
#»
consider a plane Π of normal #» n and a line l of direction vector d . When
#»
they are perpendicular, #» n is parallel to d , and inversely when they are
#» #»
parallel, #»
n is perpendicular to d . In general, if the angle between #»
n and d
is θ ∈ [0, π2 ], then the angle between the plane and the line is π2 − θ.

θ
#»
#»
n d

double angle(plane p, line3d l) {

return M_PI/2 - smallAngle(p.n, l.d);
}
bool isParallel(plane p, line3d l) {
return (p.n|l.d) == 0;
}
bool isPerpendicular(plane p, line3d l) {
return p.n*l.d == zero;
}

7.4.4 Perpendicular through a point

The line perpendicular to a plane Π of normal #»

n and going through a point
O is simply the line going through O and whose direction vector is #»
n , or
equivalently the line going through O and O + #»
n.

O + #»
n

#»
n O

line3d perpThrough(plane p, p3 o) {return line(o, o+p.n);}

#»
The plane perpendicular to a line l of direction vector d and going
#»
through a point O is simply the plane containing O and whose normal is d .

136
 #»
d
O

plane perpThrough(line3d l, p3 o) {return plane(l.d, o);}

7.5 Polyhedrons

In this section, we give a brief introduction to polyhedrons, and show how

to compute their surface area and their volume.

7.5.1 Definition

A polyhedron is a region of space delimited by polygonal faces. Generally,

we will describe a polyhedron by listing its faces. Some basic conditions
apply:
• all the faces are polygons that don’t self-intersect;
• two faces either share a complete edge, or share a single vertex, or
have no common point;
• all edges are shared by exactly two faces;
• if we define adjacent faces as faces that share an edge, all faces are
connected together.
Here is a polyhedron that respects those conditions:

y
x

Face type Face visibility

8 triangles 7 visible
4 quadrilaterals 5 hidden

137
 Note that those conditions don’t exclude nonconvex polyhedrons (like
the example above), but they do exclude self-crossing polyhedrons.

7.5.2 Surface area

To compute the surface area of a polyhedron, we need to compute the area

of their faces. Like we do for polygons, we denote a face by listing its vertices
in order, like P1 P2 P3 P4 . The vertices must all be coplanar and the edges
should not intersect except at their ends.

z
P4

P1 P3

y
x P2

How do we find the area of a face P1 · · · Pn ? First let’s take the most
# » # »
simple case: a triangle ABC. If we compute cross product AB × AC, its
direction is perpendicular to the triangle and its norm is

|AB| |AC| sin θ

# » # »
where θ is the amplitude of angle between AB and AC. This is twice the
area of triangle ABC,
# » as# was already noted in section 6.6.1. So the area of
»
triangle ABC is AB × AC

# » # »
AB × AC
C

A
B

If we rewrite the vectors we can obtain a more symmetric expression:

# » # »
AB × AC = (B − A) × (C − A)
=B×C −B×A−A×C +A×A
=A×B+B×C +C ×A

Let’s extend this to a quadrilateral ABCD. There are two cases:

138
 • Triangles ABC and ACD are oriented in the same way. In this case,
# » # » # » # »
vectors AB × AC and AC × AD point in the same direction, and the
# » # »
areas should be added together. So we take the vector sum AB × AC +
# » # »
AC × AD.
• Triangles ABC and ACD are oriented in different ways (the angle at
# » # » # » # »
either B or D is concave). In this case, vectors AB × AC and AC × AD
point in opposite directions, and we should take the difference of the
# » # » # » # »
areas. So again, taking the vector sum AB × AC + AC × AD will
produce the desired effect.

Same orientation Different orientation

D
D
C
A A B

B C

# » # » # » # » # » # » # » # »
AB × AC AC × AD AB × AC AC × AD

We can reformulate the sum in the same way:

# » # » # » # »
AB × AC + AC × AD = (A × B + B × C + C × A)
+ (A × C + C × D + D × A)
=A×B+B×C +C ×D+D×A

If we continue with more and more vertices, we can make the following
general conclusion. Given a polygon P1 · · · Pn , we can compute the vector
area
#» P1 × P2 + P2 × P3 + · · · + Pn × P1
S =
2
#»
This vector is perpendicular to the polygon, and S gives its area. It
is oriented such that when it points towards the observer, the vertices are
numbered in counter-clockwise order.
#»
S
P5
P4

P1 P3

P2

139
 Note that this is very similar to the 2D formula for area we obtained in
section 6.6.1. The only thing that changes is that the result is a vector. We
can implement this straightforwardly:
p3 vectorArea2(vector<p3> p) { // vector area * 2 (to avoid
divisions)
p3 S = zero;
for (int i = 0, n = p.size(); i < n; i++)
S = S + p[i]*p[(i+1)%n];
return S;
}
double area(vector<p3> p) {
return abs(vectorArea2(p)) / 2.0;
}

7.5.3 Face orientation

When given an arbitrary polyhedron, an important task is to orient the faces

properly, so that we know which side is inside the polyhedron and which side
is outside. In particular, we will try to order the vertices of the faces so that
#»
their vector areas S all points towards the outside of the polyhedron. Note
that, depending on the way the polyhedron was obtained, this might already
be the case.

#»
S pointing outside (lengths not to scale)

While it’s not clear when looking at individual faces which side is inside
the polyhedron, it’s easy to deduce the correct orientation by looking at the
orientation of an adjacent face. If two faces share an edge [P Q], and the
first face lists P then Q in this order, then the other face should list them
in the other order, so that they “rotate” in the same direction. Note that
because of circularity, in P1 · · · Pn , Pn is considered to come before P1 , not
after.

140
 Q Q

R R
S S
P P

[P, Q, R] and [S, Q, P ] [P, Q, R] and [P, Q, S]

P → Q vs Q → P both P → Q
OK KO

So to orient the faces in a consistent way, start from an arbitrary face,

and perform a graph traversal on faces. Whenever you go from a face to a
neighboring face, reverse the new face’s vertex order if the common edge is
present in the same order on both faces. This will either orient all vector
areas towards the outside, or all towards the inside.
Here is a example implementation:
// Create arbitrary comparator for map<>
bool operator<(p3 p, p3 q) {
return tie(p.x, p.y, p.z) < tie(q.x, q.y, q.z);
}
struct edge {
int v;
bool same; // = is the common edge in the same order?
};

// Given a series of faces (lists of points), reverse some of them

// so that their orientations are consistent
void reorient(vector<vector<p3>> &fs) {
int n = fs.size();

// Find the common edges and create the resulting graph

vector<vector<edge>> g(n);
map<pair<p3,p3>,int> es;
for (int u = 0; u < n; u++) {
for (int i = 0, m = fs[u].size(); i < m; i++) {
p3 a = fs[u][i], b = fs[u][(i+1)%m];
// Let’s look at edge [AB]
if (es.count({a,b})) { // seen in same order
int v = es[{a,b}];
g[u].push_back({v,true});
g[v].push_back({u,true});
} else if (es.count({b,a})) { // seen in different order

141
 int v = es[{b,a}];
g[u].push_back({v,false});
g[v].push_back({u,false});
} else { // not seen yet
es[{a,b}] = u;
}
}
}

// Perform BFS to find which faces should be flipped

vector<bool> vis(n,false), flip(n);
flip[0] = false;
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
for (edge e : g[u]) {
if (!vis[e.v]) {
vis[e.v] = true;
// If the edge was in the same order,
// exactly one of the two should be flipped
flip[e.v] = (flip[u] ˆ e.same);
q.push(e.v);
}
}
}

// Actually perform the flips

for (int u = 0; u < n; u++)
if (flip[u])
reverse(fs[u].begin(), fs[u].end());
}

7.5.4 Volume

Suppose that the faces are oriented correctly. We will show how to compute
the volume of the polyhedron by taking the same approach as in section 6.6.1
for the 2D polygon area.
Let’s choose an arbitrary reference point O. We will compute the volume
of the polyhedron face by face: for a face P1 · · · Pn , if the side of the face
seen from O is inside the polygon, add the volume of pyramid OP1 · · · Pn ,

142
and otherwise subtract it. That way, by inclusion and exclusion, the final
result will be the volume inside the polyhedron.
#»
Since S always points towards the outside of the polygon, we just have
#»
to check whether S points away from O (add) or towards O (subtract).

#»
S
P2 P3
P1 P1
P3 P2
#»
S
O O
#» #»
S away from O S towards O
+ volume of OP1 P2 P3 − volume of OP1 P2 P3

How do we compute the volume of pyramid OP1 · · · Pn ? We can use the

formula
area of base × height
volume =
3
#» # »
It turns out that dot product S · OP1 computes exactly (area of base ×
height) in absolute value. Indeed, by definition
#» # » #»
S · OP1 = S |OP1 | cos θ
#» # » #»
where θ is the angle between S and OP1 . The norm S is the area of
P1 · · · Pn , the base of the pyramid, and we can easily see that |OP1 | cos θ is
the height of the pyramid (up to sign).

#»
S
P2
P1
P3
|OP1 | cos θ
θ
O

#» # »
So the absolute value of S · OP1 is equal to the volume of pyramid
#»
OP1 · · · Pn , and the dot product is positive if S points away from O, and
#»
negative if S points towards O. This is exactly the sign we want.
For the implementation, we take O to be the origin for convenience. We
divide by 6 at the end because we need to divide by 2 to get the correct area
and then by 3 because of the formula for the volume of a pyramid.

143
double volume(vector<vector<p3>> fs) {
double vol6 = 0.0;
for (vector<p3> f : fs)
vol6 += (vectorArea2(f)|f[0]);
return abs(vol6) / 6.0;
}

#»
In case the vector areas S all point towards the inside of the polyhedron
(which may happen after applying the face orientation procedure in the
previous section), vol6 will be correct but will have a negative sign. If this
#»
happens, flip all the faces so that all S now point outside.

7.6 Spherical geometry

In this section, we look at spheres and how we can define distances, segments,
intersections and areas on spheres. We then define the related concept of
3D angles and how we can compute a 3D version of the winding number
based on spherical geometry primitives.

7.6.1 Spherical coordinate system

A sphere with center O = (x0 , y0 , z0 ) and radius r is the set of points at

distance exactly r from O. We can describe it this by equation

(x − x0 )2 + (y − y0 )2 + (z − z0 )2 = r2

r
r

y
x

To describe a point on a sphere, we can either directly give its coordinates

x, y, z or use the spherical coordinate system: this is the system used to

144
position locations on Earth. We use an angle ϕ, the latitude, which tells
us how far North the point is (or South, if ϕ < 0), and an angle λ, the
longitude, which tells us how far East the point is (or West, if λ < 0). We
usually take ϕ ∈ [− π2 , π2 ] and λ ∈ (−π, π].

North

West East
ϕ
θ
y
x
South

If the sphere is centered at the origin, the position represented by coor-

dinates (ϕ, λ) is
(r cos ϕ cos λ, r cos ϕ sin λ, r sin ϕ)
where the z-axis points North and the x-axis points towards meridian λ = 0
(on Earth, the Greenwich meridian).
The function below finds the position given angles in degrees:
p3 sph(double r, double lat, double lon) {
lat *= M_PI/180, lon *= M_PI/180;
return {r*cos(lat)*cos(lon), r*cos(lat)*sin(lon), r*sin(lat)};
}

7.6.2 Sphere-line intersection

A sphere (O, r) and a line l have either 0, 1, or 2 intersection points.

0 intersections 1 intersection 2 intersections

Finding them is exactly like circle-line intersection: first compute the

projection P of the center onto the line, then find the intersections by moving
the appropriate distance forward or backward along l.

145
 r
h
O P
d

This function returns the number of intersection points and places them
in pair out if they exist.
int sphereLine(p3 o, double r, line3d l, pair<p3,p3> &out) {
double h2 = r*r - l.sqDist(o);
if (h2 < 0) return 0; // the line doesn’t touch the sphere
p3 p = l.proj(o); // point P
p3 h = l.d*sqrt(h2)/abs(l.d); // vector parallel to l, of length
h
out = {p-h, p+h};
return 1 + (h2 > 0);
}

7.6.3 Great-circle distance

The shortest distance between two points A and B on a sphere (O, r) is

given by travelling along plane OAB. It is called the great-circle distance
because it follows the circumference of one of the big circles of radius r that
split the sphere in two.

B
O θ

So computing the distance between A and B amounts to finding the

length of the circle arc joining them. This arc is subtended by angle θ, the
# » # »
angle between OA and OB, so its length is simply rθ.
double greatCircleDist(p3 o, double r, p3 a, p3 b) {
return r * angle(a-o, b-o);

146
}

This code also works if A and B are not actually on the sphere, in which
case it will give the distance between their projections on the sphere:

Note that in most 2D projections this great-circle path is not a straight

line, and it tends to bend northward in the Northern Hemisphere, and south-
ward in the Southern Hemisphere. This is why, for example, flights going
from London to Los Angeles fly over Greenland, although it is much further
North than both cities.

Greenland

London
Los Angeles

7.6.4 Spherical segment intersection

For points A and B on a sphere, we define spherical segment [AB] as the

path drawn by the great-circle distance between A and B on the sphere.
This is not well-defined if A and B are directly opposite each other on the
sphere, because there would be many possible shortest paths.
From simplicity, we assume that the sphere is centered at the origin. We
can test if a segment is valid using the following function. Note that we
accept segments where A = B.
bool validSegment(p3 p, p3 q) {
return p*q != zero || (p|q) > 0;
}

Given two spherical segments [AB] and [CD], we would like to figure
out if they intersect, and what their intersection is. This is part of a more

147
general problem: given two segments [AB] and [CD] in space, if we view
them from an observation point O, does one of them hide part of the other,
that is, is there a ray from O that touches them both?

B
B C
C D
D O

A
A
common point on sphere common ray from O

We will solve the general problem, and make sure that our answer is
always exact when points A, B, C, D are integer points. To do this, we will
separate cases just like we did for 2D segment intersection in section 6.5.2:
1. Segments [AB] and [CD] intersect properly, that is, their intersection
is one single point which is not an endpoint of either segment. For
the general problem this means that there is a single ray from O that
touches both [AB] and [CD], and it doesn’t touch any of A, B, C, D.
2. In all other cases, the intersection, if it exists, is determined by the
endpoints. If it is a single point, it must be one of A, B, C, D, and if
it is a whole segment, it will necessarily start and end with points in
A, B, C, D.
For the rest of explanation, we will consider the case of spherical segment
intersection, because it’s easier to visualize, but it should be easy to verify
that this also applise to the general problem.

Proper intersection

Let’s deal with the first case: there is a single proper intersection point I.
For this to be the case, A and B must be on either side of plane OCD, and
C and D must be on either side of plane OAB. Put another way, A and
B must be on either side of the great circle containing C and D, and vice
versa.

B
C D

148
 We can check this with mixed product. We have to verify that
• oA = (C × D) · A and oB = (C × D) · B have opposite signs;
• oC = (A × B) · C and oD = (A × B) · D have opposite signs.
However, this time it’s not enough. Sometimes, even though the condi-
tions above are verified, there is no intersection, because the segments are
on opposite sides of the sphere:

D
C
A

C and D are on the other side of the sphere

To eliminate this kind of case, we also have to check that oA and oC have
opposite signs (this is clearly not the case here).

Exercise 7
Consider a few more examples and verify that these criteria correctly
detect proper intersections in all cases.

The intersection point I must be in the intersection of planes OAB and

#»
OCD. So direction OI must be perpendicular to their normals A × B and
C × D, that is, parallel to (A × B) × (C × D). Multiplying this by the sign
of oD gives the correct direction.
This is implemented by the code below. Note that the result, out, only
gives the direction of the intersection. If we want to find the intersection on
the sphere, we need to scale it to have length r.
bool properInter(p3 a, p3 b, p3 c, p3 d, p3 &out) {
p3 ab = a*b, cd = c*d; // normals of planes OAB and OCD
int oa = sgn(cd|a),
ob = sgn(cd|b),
oc = sgn(ab|c),
od = sgn(ab|d);
out = ab*cd*od; // four multiplications => careful with overflow
!
return (oa != ob && oc != od && oa != oc);
}

149
Improper intersections

To deal with the second case, we will do as for 2D segments and test for
every point among A, B, C, D if it is on the other segment. If it is, we add
it to a set S. S will contain 0, 1, or 2 distinct points, describing an empty
intersection, a single intersection point or an intersection segment.

C
D D
D
C C
A B A B A B

S=∅ S = {C} S = {B, C}

no intersection intersection point intersection
segment

To check whether a point P is on spherical segment [AB], we need to

check that P is on plane OAB, but also that P is is “between“ rays [OA)
and [OB) on that plane.
Let #»
n = A × B, a normal of plane OAB. Checking that P is on plane
OAB is easy: #»
n · P should be 0. If P is indeed on plane OAB, then we can
check if it is to the “right” of [OA) by looking at cross product A × X. It
should be perpendicular to plane OAB. If it is in the same direction as #» n,
then P is to the right of OA, and if it is in the opposite direction, then P is
to the left of OA. So we need to check #» n · (A × P ) ≥ 0. Similarly, to check
that P is to the left of OB, we should check #» ˙ × X) ≤ 0.
n (B

#»
n #»
n #»
n

P O O O
P
A B A P B A B

left of [OA) between [OA) and right of [OB)

[OB)
KO OK KO

There remains only one special case: if A and B are the same point on
#»
the sphere, then #»
n = 0 , and then we should just check that P is also that
same point.

150
 We arrive at the following implementation. To handle the general prob-
lem, instead of directly checking for equality between P and A or B, we
check that they are in the same direction with the cross product.
bool onSphSegment(p3 a, p3 b, p3 p) {
p3 n = a*b;
if (n == zero)
return a*p == zero && (a|p) > 0;
return (n|p) == 0 && (n|a*p) >= 0 && (n|b*p) <= 0;
}

Now we just have to put all of this together in one function. First we
check for a proper intersection, then if there is none we check segment by
segment and add the points to set S. Since (as mentioned) we can’t check
for equality directly, we use a custom set structure that checks if the cross
product is zero for every point already in the set.
struct directionSet : vector<p3> {
using vector::vector; // import constructors
void insert(p3 p) {
for (p3 q : *this) if (p*q == zero) return;
push_back(p);
}
};
directionSet intersSph(p3 a, p3 b, p3 c, p3 d) {
assert(validSegment(a, b) && validSegment(c, d));
p3 out;
if (properInter(a, b, c, d, out)) return {out};
directionSet s;
if (onSphSegment(c, d, a)) s.insert(a);
if (onSphSegment(c, d, b)) s.insert(b);
if (onSphSegment(a, b, c)) s.insert(c);
if (onSphSegment(a, b, d)) s.insert(d);
return s;
}

7.6.5 Angles on a sphere

Given two spherical segments [AB] and [AC] on a sphere around the origin
O, how do we compute the amplitude of the angle they form on the surface
of the sphere at A? This angle is equal to the angle between planes OAB
and OAC, or more precisely between their normals A × B and A × C. Thus
we can find the angle using angle(), which gives values in [0, π].

151
 A×B A×C

O
C C
A θ B A θ B

angle ABC planes OAB, OAC

double angleSph(p3 a, p3 b, p3 c) {
return angle(a*b, a*c);
}

If instead of values in [0, π], we want to know the oriented angle3 between
[AB] and [AC], that is, how much we rotate if we go from B to C around A
counterclockwise, then we need to know on which side of plane OAB point
C lies. If C lies “to the left” of plane OAB, the angle given by angle() is
correct, but if C lies “to the right”, we should subtract it from 2π.

C B
A θ B A θ C

≈ 30◦
angleSph(a,b,c) angleSph(a,b,c)≈ 30◦
orientedAngleSph(a,b,c) ≈ 30◦ orientedAngleSph(a,b,c) ≈ 330◦

double orientedAngleSph(p3 a, p3 b, p3 c) {
if ((a*b|c) >= 0)
return angleSph(a, b, c);
else
return 2*M_PI - angleSph(a, b, c);
}

7.6.6 Spherical polygons and area

Given points P1 , . . . , Pn on a sphere, let’s call spherical polygon P1 · · · Pn

the region on the sphere delimited by spherical segments [P1 P2 ], [P2 P3 ], . . . ,
3
We defined a similar notion in 2D in section 6.3.2.

152
[Pn P1 ], and which is on the left when travelling from P1 to P2 . The counter-
clockwise order is important here because both “sides” on the contour are
valid candidates.

D D

C C
A A
B B

area of ABCD area of DCBA

Computing the area of such a spherical polygon is surprisingly simple.

First, let’s consider the case of a spherical triangle ABC. It’s area is given
by
r2 (α + β + γ − π)
where r is the radius of the sphere and α, β, γ are the amplitudes of the
three interior angles of ABC. Note that this would be equal to 0 if ABC,
but because of the curvature of the sphere, the angles of a triangle actually
add up to more than π.
This is actually pretty easy to prove. If we prolong the segments [AB],
[BC], and [CA] into their full great-circles, this splits the sphere into 8 parts,
of which four are the direct image of each other by point reflection around
the center of the sphere. Let’s call S the area of triangle ABC, and SA (resp.
SB , SC the area of the triangle on the other side of [BC] (resp. [CA], [AB]).

SA
C

SC S
B
A

SB

Since those four triangles cover half of the sphere together, we have
S + SA + SB + SC = 2πr2 . Besides if we take triangle ABC and the triangle
on the other side of [BC], together they form a whole spherical wedge 4 of
angle α. So their combined area should be α/2π of the total area, that is
S + SA = 2αr2 . Similarly, we obtain S + SB = 2βr2 and S + SC = 2γr2 .
4
A section of a sphere determined by two flat cuts going through the center. https:
//en.wikipedia.org/wiki/Spherical_wedge

153
 Combining those four equations, we obtain

2S = (S + SA ) + (S + SB ) + (S + SC ) − (S + SA + SB + SC )
= r2 (2α + 2β + 2γ − 2π)

which is the desired result.

The formula can be extended to an arbitrary spherical polygon P1 · · · Pn .
The area is given by

r2 sum of interior angles − (n − 2)π

 

This can be proven by decomposing the n-gon into n − 2 triangles.

double areaOnSphere(double r, vector<p3> p) {
int n = p.size();
double sum = -(n-2)*M_PI;
for (int i = 0; i < n; i++)
sum += orientedAngleSph(p[(i+1)%n], p[(i+2)%n], p[i]);
return r*r*sum;
}

7.6.7 Solid angle

The solid angle subtended by an object at an observation point O is the

apparent size of the object when looking at it from O. For example, the Sun
and the Moon have roughly the same apparent size when watched from the
Earth, even though their actual sizes are very different. So we say that they
subtend the same solid angle at the observation point that is Earth.
Let’s define it more precisely. Just like the planar angle subtended by
an object is the length of the object once it is projected onto a unit circle
around the point, the solid angle subtended by an object is the area of the
object once it is projected onto a unit sphere around the point.

O O

planar angle solid angle

154
 The unit for solid angles is the steradian (sr), and because the area of
a unit sphere is 4π, a solid angle of 4π means that the observation point is
completely surrounded, while a solid angle of 2π means that half of the view
is covered.
We can easily find the solid angle subtended by a polygon by using the
function areaOnSphere() we just defined and setting r = 1. Indeed, all it
does is compute angles, so the distance from the origin O doesn’t matter.

This also allows us to find the solid angle subtended by a polyhedron if

we know which faces are visible from O.
Math insight
#»
The solid angle subtended by a small surface d S at a position #» r is
inversely proportional to the square of the distance from the origin,
#»
k #»
r k2 , and proportional to the cosine of the angle between #»
r and d S ,
because a surface seen from sideways occupies less of the view. So we
can also find solid angles with the following integral:
Z #» #»
r × dS
Ω=
k #»
r k3

7.6.8 3D winding number

We can use this notion of solid angle to implement a 3D version of winding

number that we defined in section 6.6.3. Given an observation point O and
a polyhedron, we will compute an integer that is
• 0 if O is outside the polyhedron;
#»
• 1 if O is inside the polyhedron, and the vector areas S of the faces are
oriented towards the outside;
#»
• −1 if O is inside the polyhedron, and the vector areas S of the faces
are oriented towards the inside.
To do this, we will consider the faces one by one. For each one, if its
#»
vector area S points away from O, we add the solid angle it subtends to the
total, and otherwise we subtract it. That way:

155
 • if O is outside of the polyhedron, the solid angles will cancel out;
#»
• if O is inside of the polyhedron and the S point towards the outside,
there will mostly be additions and the total will add up to 4π;
#»
• if O is inside the polyhedron and the S point towards the inside, there
will mostly be subtractions and the total will add up to −4π.
Dividing this total angle by 4π gives the desired winding number.

#»
#» S
S

areaOnSphere() ≈ 0.079 areaOnSphere() ≈ 12.487

areaOnSphere() − 4π ≈ −0.079

To find what quantity to add or subtract for each face, we will use
#»
function areaOnSphere() directly. If S points away from O, it will return a
value in (0, 2π), the area of the projection of the face a unit sphere, which
#»
we should keep. If S points towards O, it will return a value in (2π, 4π),
the area of the rest of the unit sphere, so we should remove 4π to get the
subtraction we want.
Since we always want the value to be in (−2π, 2π) in the end, we can
use function remainder(), giving the simple implementation below.
int windingNumber3D(vector<vector<p3>> fs) {
double sum = 0;
for (vector<p3> f : fs)
sum += remainder(areaOnSphere(1, f), 4*M_PI);
return round(sum / (4*M_PI));
}

156
Appendix A

Solutions to the exercises

Exercise 1
Prove that (r1 cis ϕ1 ) ∗ (r2 cis ϕ2 ) = (r1 r2 ) cis(ϕ1 + ϕ2 ) using this new
definition of product.

(r1 cis ϕ1 ) ∗ (r2 cis ϕ2 )

= (r1 cos ϕ1 + (r1 sin ϕ1 )i) ∗ (r2 cos ϕ2 + (r2 sin ϕ2 )i)
= r1 r2 [(cos ϕ1 cos ϕ2 − sin ϕ1 sin ϕ2 )
+ (cos ϕ1 sin ϕ2 + sin ϕ1 cos ϕ2 )i]
= r1 r2 (cos(ϕ1 + ϕ2 ) + i sin(ϕ1 + ϕ2 ))
= r1 r2 cis(ϕ1 + ϕ2 )

[Back to exercise]

Exercise 3
What value will areaPolygon() (section 6.6.1) give when applied to a
closed polyline that crosses itself, like the curve above, instead of a
simple polygon? Assume we don’t take the absolute value.

It will give the sum of the areas of the parts delimited by the curve, multi-
plied by their corresponding winding numbers. For the curve below, it will
give the sum of:
• 1 × the area of the part containing A3 and A4 ;
• 2 × the area of the part containing A5 ;
• −1 × the area of the part containing A6 .

157
 A2
A3
A5

A4

A6
A1

[Back to exercise]

Exercise 5
Show that those properties also apply to the mixed product. For
example, ( #»
u × #» #» = ( #»
v)·w #» · #»
v × w) u and ( #»
u × #» #» = −( #»
v)·w #» · #»
u × w) v.

This can be derived from the properties of orient(P, Q, R, S) by setting P =

#»
0 , Q = #»
u , R = #»
v and S = w.#» Indeed, in this case
 # » # » # »
orient(P, Q, R, S) = P Q × P R · P S
h #»  #»i  #» #»
= #» u − 0 × #» v −0 · w− 0
= ( #»
u × #»
v)·w#»

[Back to exercise]

Exercise 6
A convenient way to check whether two lines P Q and RS are skew is
# » # » # »
to check whether P Q × RS · P R 6= 0: in fact you can replace P R
by any vector going from P Q to RS.
Using the properties of dot product, cross product and orient(), prove
that  # » # » # »
P Q × RS · P R = − orient(P, Q, R, S)

Note that for any vectors #» #» we have ( #»

v and w #» · w
v × w) #» = 0. This is because
#» #» #»
v × w is perpendicular to w and the dot product is zero for perpendicular
vectors.

158
We develop:
 # » # » # »  # »  # » # » # »
P Q × RS · P R = P Q × P S − P R ·PR
 # » # » # » # » # »
= PQ × PS − PQ × PR ·PR
 # » # » # »  # » # » # »
= PQ × PS ·PR − PQ × PR ·PR
 # » # » # »
= PQ × PS ·PR
= orient(P, Q, S, R)
= − orient(P, Q, R, S)

[Back to exercise]

159
Appendix B

Omitted proofs

B.1 Precision bounds for +, −, ×

We first formulate an assumption on the rounding operation round(). In
this section, M and  are positive real constants.
Assumption 1. The rounding of a value x has a relative error of at most .
Therefore, if |x| ≤ M d , as we will always assume of a d-dimensional value,
then
| round(x) − x| ≤ M d 

To give a solid formalism to our notions of d-dimensional values and

“computed in n operations”, we introduce the following recursive definition.
Definition 1. A quadruplets (x, x0 , d, n) is a valid computation if |x| ≤ M d
and one of these holds:
(a) x = x0 , n = 0;
(b) (a, a0 , da , na ) and (b, b0 , db , nb ) are valid computations, n = na + nb + 1
and either:
(i) d = da = db , x = a + b, x0 = round(a0 + b0 ) and |a0 + b0 | ≤ M d ;
(ii) d = da = db , x = a − b, x0 = round(a0 − b0 ) and |a0 − b0 | ≤ M d ;
(iii) d = da + db , x = ab, x0 = round(a0 b0 ) and |a0 b0 | ≤ M d .

Note that valid computations are strongly limited by the assumptions

we place on the magnitude of the results, both theoretical and actual.
Theorem 1. If (x, x0 , d, n) is a valid computation, then
|x0 − x| ≤ M d ((1 + )n − 1) .

We will prove the theorem by induction on the structure of valid com-

putations. We will separate the proof into two lemmas: first addition and
subtraction together in Lemma 2, then multiplication in Lemma 3.

160
Lemma 1. Let f (x) = (1 + )x − 1. If a, b > 0, then f (a) + f (b) ≤ f (a + b).

Proof. Clearly, f is convex. From convexity we find

b a
f (a) ≤ f (0) + f (a + b)
a+b a+b
a b
f (b) ≤ f (0) + f (a + b).
a+b a+b

Therefore, f (a) + f (b) ≤ f (0) + f (a + b) = f (a + b).

Lemma 2 (addition and subtraction). Let operator ∗ be either + or −. If

(a, a0 , d, na ) and (b, b0 , d, nb ) are two valid computations for which Theorem 1
holds and (a ∗ b, round(a0 ∗ b0 ), d, na + nb + 1) is a valid computation, then
Theorem 1 holds for it as well.

Proof. From the hypotheses know that

|a0 − a| ≤ M d ((1 + )na − 1)

|b0 − b| ≤ M d ((1 + )nb − 1)
|a0 ∗ b0 | ≤ M d .

We find

| round(a0 ∗ b0 ) − (a ∗ b)|
= |(round(a0 ∗ b0 ) − (a0 ∗ b0 )) + ((a0 ∗ b0 ) − (a ∗ b))|
≤ | round(a0 ∗ b0 ) − (a0 ∗ b0 )| + |(a0 − a) ∗ (b0 − b)|
≤ M d  + |a0 − a| + |b0 − b|
≤ M d  + M d ((1 + )na − 1) + M d ((1 + )nb − 1)
= M d [f (1) + f (na ) + f (nb )]
≤ M d f (na + nb + 1)
= M d (1 + )na +nb +1 − 1

where the step before last follows from two applications of Lemma 1.

Lemma 3 (multiplication). If (a, a0 , da , na ) and (b, b0 , db , nb ) are two valid

computations for which Theorem 1 holds and (ab, round(a0 b0 ), da + db , na +
nb + 1) is a valid computation, then Theorem 1 holds for it as well.

161
Proof. From the hypotheses we know that

|a| ≤ M d
|b| ≤ M d
|a0 − a| ≤ M da ((1 + )na − 1)
|b0 − b| ≤ M da ((1 + )nb − 1)
|a0 b0 | ≤ M da +db .

We find

| round(a0 b0 ) − ab)|
= |(round(a0 b0 ) − a0 b0 ) + (a0 b0 − ab)|
≤ | round(a0 b0 ) − a0 b0 | + |(a0 − a)b + (b0 − b)a + (a0 − a)(b0 − b)|
≤ M da +db  + |a0 − a||b| + |b0 − b||a| + |a0 − a||b0 − b|
≤ M da +db  + M da ((1 + )na − 1) M db + M db ((1 + )nb − 1) M da
+ M da ((1 + )na − 1) M db ((1 + )nb − 1)
= M da +db  + ((1 + )na − 1) + ((1 + )nb − 1)


+ ((1 + )na − 1) ((1 + )nb − 1)



= M da +db  + (1 + )na +nb − 1

 

= M da +db [f (1) + f (na + nb )]

≤ M da +db f (na + nb + 1)
= M da +db (1 + )na +nb +1 − 1

where the step before last follows from Lemma 1.

Proof of Theorem 1. By induction on the recursive structure of valid com-

putations (see Definition 1). Case (a) is trivial because |x0 − x| = 0. For
case (b), the inductive step for (i) and (ii) follows from Lemma 2 while that
of (iii) follows from Lemma 3.

162
Bibliography

[1] Benjamin A. Burton and Mathias Hiron. “Creating informatics olympiad

tasks: exploring the black art”. In: Olympiads in Informatics (2008).
issn: 1822-7732.
[2] Gyula Horváth and Tom Verhoeff. “Numerical difficulties in pre-university
informatics education and competitions”. In: Informatics in Education
(2003).
[3] Lutz Kettner et al. “Classroom examples of robustness problems in
geometric computations”. In: Computational Geometry 40.1 (2008),
pp. 61–78. url: https : / / people . mpi - inf . mpg . de / ˜kettner / pub /
nonrobust_esa_04.pdf.

[4] Antti Laaksonen. Guide to Competitive Programming. Springer Inter-

national Publishing, 2017. doi: 10.1007/978-3-319-72547-5.
[5] “The International Olympiad in Informatics Syllabus”. In: (). url:
https://people.ksp.sk/˜misof/ioi-syllabus/.

163
Rue Archimède, 1 bte L6.11.01, 1348 Louvain-la-Neuve, Belgium www.uclouvain.be/epl