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.

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

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.

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

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