# 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.

## 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
```

## 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.

### Divisible by 17 Exercise

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

### 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
```