Imagine you stand on a distance, say \( 10 \) m away, watching someone throwing a ball upwards. A straight line from you to the ball will then make an angle with the horizontal that increases and decreases as the ball goes up and down. Let us consider the ball at a particular moment in time, at which it has a height of \( 10 \) m.
What is the angle of the line then? Again, this could easily be done with a calculator, but we continue to address gentle mathematical problems when learning to program. Before thinking of writing a program, one should always formulate the algorithm, i.e., the recipe for what kind of calculations that must be performed. Here, if the ball is \( x \) m away and \( y \) m up in the air, it makes an angle \( \theta \) with the ground, where \( \tan\theta = y/x \). The angle is then \( \tan^{-1}(y/x) \).
Let us make a Python program for doing these calculations. We introduce
names x and y for the position data \( x \) and \( y \), and the
descriptive name angle for the angle \( \theta \).
The program is stored in a file
ball_angle_first_try.py:
x = 10 # Horizontal position
y = 10 # Vertical position
angle = atan(y/x)
print (angle/pi)*180
Before we turn our attention to the running of this program, let us
take a look at one new thing in the code. The line angle = atan(y/x),
illustrates how the function atan, corresponding to \( \tan^{-1} \)
in mathematics, is called with the
ratio y/x as input parameter or argument.
The atan function takes one argument, and the computed value is
returned from atan. This means that where we see atan(y/x),
a computation is performed (\( \tan^{-1}(y/x) \)) and the result "replaces"
the text atan(y/x). This is actually no more magic than if we
had written just y/x: then the computation of y/x would take place,
and the result of that division would replace the text y/x.
Thereafter, the result is assigned to the name angle
on the left-hand side of =.
Note that the trigonometric functions, such as atan, work with
angles in radians. The return value of atan must hence be converted
to degrees, and that is why we perform the computation (angle/pi)*180.
Two things happen in the print statement: first, the computation
of (angle/pi)*180 is performed, resulting in a real number, and second,
print prints that real number. Again, we may think that the
arithmetic expression is replaced by its results and then print
starts working with that result.
If we next execute ball_angle_first_try.py, we get an error message on
the screen saying
NameError: name 'atan' is not defined
WARNING: Failure executing file: <ball_angle_first_try.py>
We have definitely run into trouble, but why? We are told that
name 'atan' is not defined
so apparently Python does not recognize this part of the code as
anything familiar. On a pocket calculator the inverse tangent function is
straightforward to use in a similar way as we have written in the
code. In Python, however, this function has not yet been imported
into the program. A lot of functionality is available to us in
a program, but much more functionality exists in Python libraries,
and to activate this functionality, we must explicitly import it.
In Python, the atan function is grouped together with many
other mathematical functions in the library called math.
Such a library is referred to as a module in correct Python language.
To get access to atan in our program we have to write
from math import atan
Inserting this statement at the top of the program and rerunning it,
leads to a new problem: pi is not defined. The variable pi, representing
\( \pi \), is also available in the math module, but it has to be imported
too:
from math import atan, pi
It is tedious if you need quite some math functions and variables in
your program, e.g., also sin, cos, log, exp, and so on.
A quick way of importing everything in math at once, is
from math import *
We will often use this import statement and then get access to all common mathematical functions. This latter statement is inserted in a program named ball_angle.py:
from math import *
x = 10 # Horizontal position
y = 10 # Vertical position
angle = atan(y/x)
print (angle/pi)*180
This program runs perfectly and produces 45.0 as output, as it should.
At first, it may seem cumbersome to have code in libraries, since you have to know which library to import to get the desired functionality. Having everything available anytime would be convenient, but this also means that you fill up the memory of your program with a lot of information that you rather would use for computations on big data. Python has so many libraries with so much functionality that one simply needs to import what is needed in a specific program.