To do multiple calculations, you can type one mathematical calculation after another, such as

X = 34 + 7
Y = X * 89

Although this works, it can get clumsy, especially if you need to write more than a handful of equations. As a simple solution, you can cram multiple equations into a single, big equation, such as

Y = 34 + 7 * 89

The problem is, how does the computer calculate this equation? Does it first add 34 + 7 and then use this result (41) to multiple with 89? Or does it first multiply 7 by 89 and then add this result (623) to 34?

Depending on the order it calculates its mathematical operators, the result is either 3649 or 657, two obviously different answers.

To calculate any equation with multiple mathematical operators, computers follow rules that define which mathematical operators get calculated first (known as operator precedence). Table 3-3 lists common operator precedence for most programming languages where the top operators have the highest precedence, and the lowest operators at the bottom of the table have the lowest precedence.

If an equation contains operators that have equal precedence, the computer calculates the result from left to right, such as

X = 8 − 3 + 7

First, the computer calculates 8 − 3, which is 5 Then it calculates 5 + 7, which is 12.

If an equation contains operators with different precedence, the computer calculates the highest precedence operator first. Looking at this equation, you can see that the multiplication (*) operator has higher precedence than the addition (+) operator.

Y = 34 + 7 * 89

So the computer first calculates 7 * 89, which is 623 and then adds 34 to get 657.

What if you really wanted the computer to first calculate 34 + 7 and then multiply this result by 89? To do this, you have to enclose that part of the equation in parentheses, such as

Y = (34 + 7) * 89

The parentheses tell the computer to calculate that result first. So first this is how the computer calculates the preceding equation:

Y = (34 + 7) * 89
Y = 41 * 89
Y = 3649

Using basic mathematical operators, you can create any type of complicated formulas, such as calculating a quadratic equation or a generating random numbers. However, writing equations to calculate something as common (to scientists and mathematicians, anyway) as logarithms, might seem troublesome. Not only do you have to waste time writing such an equation, but you have to spend even more time testing to make sure it works correctly as well.

So to prevent people from rewriting commonly needed equations, most programming languages include built-in math functions that are either

The advantage of using built-in math functions is that you can use them without having to write any extra command that you may not want to do or may not know how to do. For example, how do you calculate the square root of a number?

Most likely, you won't have any idea, but you don't have to because you can calculate the square root of a number just by using that language's built-in square root math function. So if you wanted to know the square root of 34 and store it in an Answer variable, you could just use the sqrt math function, such as

Answer = sqrt(34)

Table 3-4 lists some common built-in math functions found in many programming languages.

By using math operators and math functions, you can create complex equations, such as

x = 67 * cos (5) + sqrt (7)

Rather than plug fixed values into a math function, it's more flexible just to plug in variables instead, such as

Angle = 5
Height = 7
X = 67 * cos (Angle) + sqrt (Height)

The simplest way to search for a pattern is to look for a single character. For example, you might want to know if a certain string begins with the letter b, ends with the letter t, and contains exactly one character between. Although you could repetitively check every three-character string that begins with b and ends with t, like bat or but, it's much easier to use a single-character wildcard instead, which is a dot or period character (.).

So if you want to find every three-letter string that begins with a b and ends with a t, you'd use this regular expression:

b.t

To search for multiple characters, use the (.) wildcard multiple times to match multiple characters. So the pattern b..t matches the strings boot and boat with the two (..) wildcards representing the two characters between the b and the t.

Of course, the b..t pattern doesn't match bat because bat has only one character between the b and the t. Nor does it match boost because boost has more than two characters between the b and the t.

The (.) wildcard can find any character whether it's a letter, number, or symbol. Rather than search for any character, you can also search for a list of specific characters by using the square bracket [ ] symbols.

Enclose the characters you want to find inside the square brackets. So if you want to find all strings that begin with b, end with t, and have an a, o, or u between, you could use this regular expression:

b[aou]t

The preceding example finds words, like bat or bot, but doesn't find boat or boot because the regular expression looks only for a single character sandwiched between the b and the t characters.

As an alternative to listing the specific characters you want to find, you can also use the not (^) character to tell the computer which characters you don't want to find, such as

b[^ao]t

This tells the computer to find any string that doesn't have an a or an o between the b and the t, such as but. If you have the string bat, the b[^ao]t regular expression ignores it.

Sometimes you may want to find a string that has a specific character, but you don't care how many copies of that character you may find. That's when you can use the (*) wildcard to search for zero or more specific characters in a string.

So if you want to find a string that begins with bu and contains zero or more z characters at the end, you could use this regular expression:

buz*

This finds strings like bu, buz, buzz, and buzzzzzz. Because you want to find zero or more copies of the z character, you place the (*) wildcard after the z character.

The (*) finds zero or more characters, but what if you want to find at least one character? That's when you use the (+) wildcard instead. To search for a character, you place the (+) wildcard after that character, such as

buz+

This finds buz and buzzzz but not bu because the (+) wildcard needs to find at least a z character.

Wildcards can match zero or more characters, but sometimes you may want to know whether a particular character falls within a range or characters. To do this, you can use ranges. For example, if you want to know whether a character is any letter, you could use the pattern [a-z] as follows:

bu[a-z]

This finds strings, such as but, bug, or bus, but not bu (not a three-character string). Of course, you don't need to search for letters from a to z. You can just as well search for the following:

bu[d-s]

This regular expression finds bud and bus but not but (because the t lies outside the range of letters from d to s).

You can also use ranges to check whether a character falls within a numeric range, such as

21[0-9]

This finds the strings 212 and 210. If you only wanted to find strings with numbers between 4 and 7, you'd use this regular expression:

21[4-7]

This finds the strings 215 but not the strings 210 or 218 because both 0 and 8 lie outside the defined range of 4-7. Table 3-6 shows examples of different regular expressions and the strings that they find.

By stringing multiple regular expression wildcards together, you can search for a variety of different string patterns, as shown in Table 3-6.

You can always combine regular expressions to create complicated search patterns, such as the last regular expression in Table 3-6:

p[aei].[0-9]

This regular expression might look like a mess, but you can dissect it one part at a time. First, it searches for this four-character pattern:

As you can see, regular expressions give you a powerful and simple way to search for various string patterns. After you find a particular string, you can manipulate it with the built-in string manipulation functions and operators in a specific programming language.

The Not operator takes a Boolean value and converts it to its opposite. So if you have a True value, the Not operator converts it to False and vice versa. At the simplest example, you can use the Not operator like this:

Not(True) = False

Like using fixed values in comparison operators (5 > 2), using fixed values with Boolean operators is rather pointless. Instead, you can use variables and comparison operators with Boolean operators, such as

Not(Age > 2)

If the value of the Age variable is 3, this Boolean operation evaluates to

Not(Age > 2)
Not(3 > 2)
Not(True)
False

The And operator takes two Boolean values and converts them into a single Boolean value. If both Boolean values are True, the And operator returns a True value. Otherwise, the And operator always returns a False value, as shown in Table 3-8, or the Truth table.

So if the value of the Age variable is 3, this is how the following And operator evaluates an answer:

(Age > 2) AND (Age >= 18)
(3 > 2) AND (3 >= 18)
True AND False
False

If the value of the Age variable is 25, this is how the And operator evaluates an answer:

(Age > 2) AND (Age >= 18)
(25 > 2) AND (25 >= 18)
True AND True
True

Rather than use the word and to represent the And operator, curly bracket languages, such as C/C++, use the ampersand (&) symbol instead.

Like the And operator, the Or operator takes two Boolean values and converts them into a single Boolean value. If both Boolean values are False, the Or operator returns a False value. Otherwise, the Or operator always returns a True value, as shown in Table 3-9.

So if the value of the Age variable is 3, this is how the following Or operator evaluates an answer:

(Age > 2) OR (Age >= 18)
(3 > 2) OR (3 >= 18)
True OR False
True

If the value of the Age variable is 1, this is how the Or operator evaluates an answer:

(Age > 2) OR (Age >= 18)
(1 > 2) OR (1 >= 18)
False OR False
False

Rather than use the word or to represent the Or operator, curly bracket languages, such as C/C++, use the vertical line (|) symbol instead.

The Xor operator is an exclusive Or. The Xor operator takes two Boolean values and converts them into a single Boolean value:

So if the value of the Age variable is 3, this is how the following Xor operator evaluates an answer:

(Age > 2) XOR (Age >= 18)
(3 > 2) XOR (3 >= 18)
True XOR False
True

If the value of the Age variable is 1, this is how the Xor operator evaluates an answer:

(Age > 2) XOR (Age >= 18)
(1 > 2) XOR (1 >= 18)
False XOR False
False

Rather than use the word xor to represent the Xor operator, curly bracket languages, such as C/C++, use the caret (^) symbol instead.

Boolean operators are used most often to make decisions in a program, such as a video game asking, "Do you want to play again?" When you choose either Yes or No, the program uses a comparison operator, such as

Answer = "Yes"

The result depends on your answer: