So! Let's talk math, because it's fun. We'll use python for this because we don't have to compile it, it's easy, and it's useful in simulation projects like Micropolis.

Let's get some things out of the way first. Python's easy to run:

$ python

Python 2.5.1 (r251:54863, May 18 2007, 16:56:43)

[GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)] on cygwin

Type "help", "copyright", "credits" or

"license" for more information.

>>>

Exiting python is also easy: CTRL-D does the trick.

We'll use different fonts to show system output and user input. A monotype font is computer-generated text; we'll use a grey background to show user input. For special characters (like CTRL-D) we'll use italics with the grey background. So the interaction above would be:

$ python

Python 2.5.1 (r251:54863, May 18 2007, 16:56:43)

[GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)] on cygwin

Type "help", "copyright", "credits" or

"license" for more information.

>>>"hello"'hello' >>>[CTRL-D]$

Okay, that was fun. ("Really?") Now, we'll be doing some stuff with a text editor, too, because we'll want to reload things instead of having to retype them, so we might as well open an editor somewhere as well.

A *triangle* is a figure that has three
sides, right? That's pretty basic stuff. There's something called a
"right triangle," which has one special thing about it: one of
the angles is always ninety degrees. (A ninety degree angle is the
kind of angle that squares have, for a simple explanation. A more
complex explanation, if you're interested, is that a circle, divided
into four equal parts, will have four right angles intersecting at
its center. If that confused you, go back to the bit about the
square. It's simpler.)

A right triangle is surprisingly,
amazingly useful. However, before we can learn to use it, we need to
learn a little more *about* it.

For simplicity, let's look at a triangle, and label its parts:

Let's rename the vertical line as segment “A.” The line at the bottom, let's call that one “B.” The “Hypotenuse” - which is, by the way, the correct name for that segment – is what we will label “C.”

Nu!^{1}
Let's play with this triangle some. That hypotenuse – line “C”,
you remember – has a *specific
length*.
Always. That length depends on the length of A and B, but if you know
the length of *any two
sides*
of a right triangle, you can *always*
tell the length of the third. (In fact, you can also tell what the specific
angles are, but that's not important to us right now.)

The
way we do this is through something called the “Pythagorean
theorem.” Pythagoras was a Greek mathematician who lived around
five hundred years before Christ was born (i.e., the beginning of the Common Era). We don't know a lot about
him because his writings haven't survived, but everyone knows
*something*
about him because the Pythagorean theorem is one of the most useful
mathematical formulas mankind has at its disposal. He may not even
have come up with it, but he gets credit for it. (Maybe the "something we know" about Pythagoras is that the Pythagorean Theorem is named after him... which isn't much, but last I checked, that's more than I had named after *me*.)

What's a theorem? Well, a theorem is something that can be proved. Simple enough, eh? (It's actually a little more complex than that, like everything else, but let's not confuse the issue any more than we already have.)

Here's what the Pythagorean Theorem actually says: “In any right triangle, the area of the square whose side is the hypotenuse (the side opposite the right angle) is equal to the sum of the areas of the squares whose sides are the two legs (the two sides that meet at a right angle).” Looking at our diagram again, C is the hypotenuse, remember?

So
if we say “A” and “B” are the *lengths*
of the sides they represent, then we can *always*
determine the length of C like this:

Exciting
stuff, huh? Let's explain everything there. The a, b, and c represent
the *lengths of the sides
they represent*
with *c*
being the side *opposite
the right angle*.

The
little superscripts there are called *exponents*.
An exponent is a way of saying “this number multiplied by itself X
times.” So 4^{2}
is the same as 4 * 4; 3^{3}
is the same as 3 * 3 * 3.
The way c^{2} is shown as the result means that whatever number we get from adding a^{2} and b^{2}, we need to determine the "square root" - the "4" in "4^{2}" up there.

So...
let's walk through this a little bit, shall we? Let's look at our
triangle, and plug in some numbers. Let's make *a* 3, and *b* 4.
That means that our equation looks like this: c=(square root of) 3*3+4*4

Let's start mathematicizing! (Yes, I made this word up.) First off, we apply our exponents, so the formula looks like this:

`c=(square root) 9+16 -
remembering that 3 ^{2} = 3 * 3 = 9 and 4^{2} = 4*4 = 16.`

Now,
our next step is to do that addition, so our formula *now* looks
like this: c = (square root of) 25

If you
remember *anything* about our friends the exponents and their cousins the square roots,
then you know that 5*5=25, which means that *c* here is 5.

We've now walked through the Pythagorean theorem in somewhat painful detail, but hopefully you understand it now.

We started off, though, with python! We immediately left it behind – it might be a good time to get back to it.

So
let's write the Pythagorean theorem as a function, so we can always
determine *c*,
given *a*
and *b*.
(We could do other stuff, too, like – given *c* and *a*,
determine *b*.
But let's hold off on that for now.)

Let's
do the simple thing first, and use the numbers we put in before.
Let's get Python to give us *c*,
if *a* and *b* are 3 and 4, respectively.

$ python

Python 2.5.1 (r251:54863, May 18 2007, 16:56:43)

[GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)] on cygwin

Type "help", "copyright", "credits" or

"license" for more information.

>>>import math>>>a=3>>>b=4>>>math.sqrt(math.pow(a,2)+math.pow(b,2))5.0 >>>[CTRL-D]$

Whoa!
That's exactly the sort of result we wanted! There's a few strange
things: the "import math" there makes “sqrt” -- Python's name
for the function that gives you the square root of a number – and
pow (which applies exponents to numbers), then we assign a and b,
then we... tell python to evaluate the square root of the addition of
the squares of *a*
and *b*.
(That's the Pythagorean theorem, after all!)

That's a lot of typing to do over and over again, though, so let's go to our handy dandy editor and write a method to do this for us.

Open
a file called “triangle.py” -- we'll be doing more stuff with
triangles over time. We'll be creating a *module*
called "triangle," stored in this file.

In this file, we need the following text, most of which will look very similar to what we just saw above:

import math

def hypotenuse(a, b):

return math.sqrt(math.pow(a,2)+math.pow(b,2))

Now, we can use this like so:

$ python

Python 2.5.1 (r251:54863, May 18 2007, 16:56:43)

[GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)] on cygwin

Type "help", "copyright", "credits" or

"license" for more information.

>>>import triangle>>>triangle.hypotenuse(3,4)5.0 >>>[CTRL-D]$

If we want to, we can play with other numbers: try a=4, b=5! (You'll find that the result is 6.4031 or so.) Feel free to put in whatever you like, and see what you get.

## {{ parent.title || parent.header.title}}

## {{ parent.tldr }}

## {{ parent.linkDescription }}

{{ parent.urlSource.name }}