2.3. Arithmetic¶

We start with the integers and integer arithmetic, not because arithmetic is exciting, but because the symbolism should be mostly familiar. Of course arithmetic is important in many cases, but C# is often used to manipulate text and other sorts of data.

2.3.1. Csharp¶

Of course we could write programs to demonstrate arithmetic, but there is a fair amount of overhead with a full program. For just testing little bits, there is another alternative: The Mono system comes with a program csharp. Let us try it out.

Open a terminal (Linux or OS X) or Mono Command Prompt window in Windows, and enter the command csharp. You should see :

Mono C# Shell, type "help;" for help

Enter statements below.
csharp>


The csharp> prompt tells you that the C# interpreter has started and is awaiting input. This allows you to create small bits of C# and test them, interactively, without having to write a full program!

Play along with the examples here, entering what comes after the prompt:

csharp> 2 + 3
5


The csharp program just has a read, evaluate, and print loop: the acronym is repl. It evaluated the expression 2 + 3 and printed the result, on a line without a prompt. Csharp can evaluate arbitrary C# expressions. It is very handy for testing as you get used to new syntax.

Subtraction works as you would expect. Blanks are optional around symbols:

csharp> 10 - 3
7


For the binary arithmetic operators, you are encouraged to add blanks to make the expression more easily readable by humans.

The csharp program is more line-oriented than the C# language. If you press the return key when what you have entered is a complete expression you see the value as a response. If your expression is clearly incomplete you get another > prompt (with no “csharp”), until you have entered enough for a full expression.

csharp> 10-
> 3
7


In math class you could enter something like 4(10) for multiplication:

csharp> 4(10)
{interactive}(1,2): error CS0119: Expression denotes a 'value',
where a 'method group' was expected


Unfortunately the error messages are not always easy to follow: it is hard to guess the intention of the user making a mistake.

The issue here is that the multiplication operator must be explicit in C#. Recall that an asterisk is used as a multiplication operator:

csharp> 4 * 10
40


Enter each of the following expressions into csharp, and think what they will produce (and then check):

2*5
2 + 3 * 4


If you expected the last answer to be 20, think again: C# uses the normal precedence of arithmetic operations: Multiplications divisions, and negations are done before addition and subtraction, unless there are parentheses forcing the order:

csharp> -(2+3)*4
-20


A sequence of operations with equal precedence also work like in math: left to right in most cases, like for combinations of addition and subtraction:

csharp> 10 - 3 + 2
9


2.3.2. Division and Remainders¶

We started with the almost direct translations from math. Division is more complicated. We continue in the csharp program:

csharp> 5.0/2.0;
2.5
csharp> 14.0/4.0;
3.5


So far so good. Now consider:

csharp> 14/4
3


What? Some explanation is in order. All data has a type in C#. When you write an explicit number without a decimal point, like 2, 17, or -237, it is interpreted as the type of an integer, called int for short.

When you include a decimal point, the type is double, representing a more general real number. This is true even if the value of the number is an integer like 5.0: the type is still double.

Addition, subtraction, and multiplication work as you would expect for double values, too:

csharp> 0.5 * (2.0 + 4.5)
3.25


If one or both of the operands to / is a double, the result is a double, close to the actual quotient. We say close, because C# stores values with only a limited precision, so in fact results are only approximate in general. For example:

csharp> 1.0/3
0.333333333333333


Small errors are also possible with the double type and the other arithmetic operations. See Type double.

Note

In C#, the result of the / operator depends on the type of the operands, not on the mathematical value of the operands.

Division with int data is handled completely differently.

If you think about it, you learned several ways to do division. Eventually you learned how to do division resulting in a decimal. In the earliest grades, however, you would say

“14 divided by 4 is 3 with a remainder of 2.”

Note the quotient is an integer 3, that matches the C# evaluation of 14/4, so having a way to generate an integer quotient is not actually too strange. The problem here is that the answer from grade school is in two parts, the integer quotient 3 and the remainder 2.

C# has a separate operation symbol to generate the remainder part. There is no standard single operator character operator for this in regular math, so C# grabs an unused symbol: % is the remainder operator. (This is the same as in many other computer languages.)

Try in the csharp shell:

csharp> 14 / 4
3
csharp> 14 % 4
2


You see that with the combination of the / operator and the % operator, you get both the quotient and the remainder from our grade school division.

Now predict and then try each of these expression in csharp:

23/5
23%5
20%5
6/8
6%8
6.0/8


Finding remainders will prove more useful than you might think in the future! Remember the strange % operator.

Note

The precedence of % is the same as / and *, and hence higher than addition and subtraction, + and -.

When you are done with csharp, you can enter the special expression

quit


There are some more details about numeric types in Value Types and Conversions.

We have been testing arithmetic expressions, with the word expression used pretty much like with normal math. More generally in C# an expression is any syntax that evaluates to a single value of some type. We will introduce many more types and operations that can be used in expressions.

2.3.2.1. Divisible by 17 Exercise¶

What is a simple expression that lets you see if an int x is divisible by 17?

2.3.2.2. Mixed Arithmetic Exercise¶

Think of the result of one of these at a time; write your prediction, and then test, and write the correct answer afterward if you were wrong. Then go on to the next.... For the ones you got wrong, can you explain the result after seeing it?

2 * 5 + 3
2 + 5 * 3
1.5 * 3
7.0/2.0
7.0/2
7/2.0
4.0 * 3 / 8
4 * 3 / 8
6 * (2.0/3)
6 * (2/3)
3 + 10 % 6
10 % 6 + 3