Skip to main content

πŸ““ Integers, Decimals, and Arithmetic

Let’s look at the data types that represent numbers: integers, longs, floats, and doubles. Between these four data types, C# covers whole and decimal numbers, as well as numbers with many digits and fewer digits. As we'll see, C# numbers are very similar to JavaScript numbers; the main difference is that JavaScript has fewer data types that represent numbers than in C#.

We'll practice working with C# number types in the REPL. Start by opening your REPL with the $ dotnet-script command in the Terminal (for Mac) or GitBash (for Windows).

Integers and Longs​

Both integers and longs represent whole numbers, that is, numbers without decimals. Integers are meant to hold smaller numbers between -2,147,483,648 and 2,147,483,647. Longs are meant to hold larger numbers between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807.

We can create a new integer like this:

> 1

Or a new long like this:

> 9222222222222222

Easy enough! But do notice this is very different than:

> "1"

The second example is a string containing an integer. Strings are the only type of data wrapped in quotation marks. If we put quotation marks around a number, it's actually a string... and will act as such!

For instance, check out what happens when we add two numbers wrapped in quotations:

> "1" + "1"

1 + 1 isn't 11! But we receive this result because the REPL is actually concatenating two strings containing the character 1 together. You likely already recognize this type of error from JavaScript but it's so common it's worth mentioning again!

We can avoid this erroneous math by avoiding quotation marks and ensuring numerical values are integers like this:

> 1 + 1

That's more like it!

Assigning Integers to Variables​

Finally, we can store integers in a variable by declaring it of the type int:

> int myAge = 45;
> myAge

We can store longs in a variable by declaring it of the type long:

> long superBigNumber = 9222222222222222;
> superBigNumber

Choosing the Right Data Type: int or long​

So what happens if we store a long in an int?

> int superBigNumber = 9222222222222222;

We'll actually get a helpful error message:

(1,22): error CS0266: Cannot implicitly convert type 'long' to 'int'. An explicit conversion exists (are you missing a cast?)

This error message lets us know that we can't store a long number into a variable that's declared for an int type. We either need to update our variable's data type to long, or convert one data type into another. Data type conversion is also called "type casting", and we'll learn about it a bit later on.

So what happens if we store a small number in a long?

> long aNumber = 2;
> aNumber

This will work as expected! In this case, the aNumber variable is of the type long, so it can hold a very large number at any point. For example, we could update the aNumber variable to hold a very large number:

> aNumber = 9222222222222222;
> aNumber

Generally we shouldn't use a long data type for small numbers that could be declared as int. That's because long takes up more space in memory than int does, and we should be mindful of conserving memory in simple cases like these.

In the example projects for this course, we'll primarily use the int data type because we won't be working with long whole numbers. However, if you know that you are dealing with very large numbers in a project you create, you should be mindful to investigate whether or not it's best to use the long data type.

Floats and Doubles​

The float and double data types represent decimal numbers like 3.14 or 9.2342342342342. Floats are meant to hold numbers with a smaller number of decimals, about 6 to 9 digits. Doubles are meant to hold numbers with a larger amount of decimals, about 15 to 17 digits. Collectively, numbers with a decimal point are referred to as floating-point numbers in computer programming.

We can create a new double like this:

> 9.2342342342342

Or a new float like this:

> 3.14F

Notice that we add the suffix F to our number to declare it as a float. We need to do this, otherwise the number 3.14 will be declared as a double. That's because C# performs an implicit conversion of all floats to doubles. If we want to make sure that this implicit conversion does not happen, we need to include the suffix F or f at the end of the number we want to declare as a float, as in 3.14F.

There's also a suffix for numbers that we want to declare as a double that we can use as needed, which is D or d. To summarize, all of the following examples creates a double:

> 9.2342342342342
> 3.14
> 0.124123123123D

Assigning Floating-Point Numbers to Variables​

We can store doubles in a variables by declaring our variable of the double data type:

> double aLongDecimal = 9.2342342342342;
> aLongDecimal

We can store floats in a variable by declaring our variable of the float data type:

> float pi = 3.14F;
> pi

Notice that we need to include an F suffix at the end of the decimal number that we're declaring as a float: 3.14F. If we don't include the F, we'll get an error:

(1,12): error CS0664: Literal of type double cannot be implicitly converted to type 'float'; use an 'F' suffix to create a literal of this type

Again, this is because C# performs an implicit conversion of all floats to doubles. If we want to make sure that this implicit conversion does not happen, we need to include the suffix F or f at the end of the number we want to declare as a float, as in 3.14F.

Choosing the Right Data Type: float or double​

If we choose the wrong data type between float and double, we're at risk of losing data and we won't get an error message about it.

Take this for example, where we store a very long decimal into a variable called testNum declared as the float type:

> float testNum = 9.2342342342342F;
> testNum

Notice that our decimal number got shortened! From 9.2342342342342 to 9.234234. Well, this is what happens in C# if we don't pick the right data type for floating point numbers.

Now, if we save a number with a small amount of decimals to a variable that's declared as a double, we'd simply be taking up more space in memory. Something like this:

> double testNum2 = 9.1;
> testNum2

However, this is the right choice if we plan to later update our testNum2 variable to a new number that has many decimals:

> testNum2 = 16.11231231222312;
> testNum2

We won't work often with decimals in the example projects in this course. However, you'll likely find use cases for float and double in your own practice projects that you create.

Arithmetic Operators​

The five arithmetic operators we used in JavaScript work the same in C#. You should recall these basic operators:

  • + for addition, as seen in the example above.
  • - for subtraction.
  • * for multiplication.
  • / for division.
  • % for modulo, which gives us the remainder of dividing two numbers.

We can use each with integers in the REPL and receive expected results. Note that the following examples use whole numbers of the int type, but they will work the same with floating point numbers.


> 1 - 1


> 1 + 1


> 2 * 2


> 4 / 2


> 5 % 2

Remember that a modulo gives us the remainder of dividing two numbers an it has anything to do with percentages!