new!###### πΆ

###### Cram Center

new!###### Study with Hours

Subjects and resources that you bookmark will appear here.

Light Mode

3 min readβ’november 16, 2020

Peter Cao

The range of variables in AP CSA refers to the range of integers, which we covered in 1.2!

Sometimes, we need to use integers in a double calculation and doubles in an integer calculation. Thus, we need a way to do this.

Pop quiz: is the value of *a* in the example below? Is it 3 or 3.0?

```
double a = 2 + 1;
```

If you said 3.0, then you are correct! Since the type of *a* is a double, the expression is **automatically widened** (converted) to a double, thus the .0 ending is added.

This can also be done manually using **casting.** Casting changes between primitive data types. See the example below:

`(double) intToConvert`

Doubles to Integers

This one is a little more complicated. What is the value of this?

```
int b = 1 + 2.0
```

In this example, the program refuses to compile! The result of this equation is 3.0, which is a double, but the type of *b* is an integer. Converting a double to an integer will result in a loss of precision, aka the decimal place (see the discussion of significant digits in our AP Chem Unit 1 Study Guide to learn more).
To use this equation correctly, we need to manually do a cast. The cast doesnβt round the decimal to the nearest integer, but instead simply **truncates** (cuts off) the decimal and leaves the integer part untouched.
However, casting only casts the first number following the cast, regardless of type, so you need to be careful with where you place your casts to avoid an incorrect calculation or a program error! Here is an example of an incorrect cast followed by two correct casts.

```
int c = (int) 1 + 2.0;
int d = 1 + (int) 2.0;
int e = (int) (1 + 2.0);
```

What happens is that only the first one will fail to compile while the other two will give a value of 3 stored into the variable. The cast converts the next number into an integer regardless of the type and not the whole expression. If you want to cast the whole expression, enclose it in parentheses.

One of the applications of using a cast is rounding to the nearest integer. Since casting doubles to integers simply truncates the decimal, we need to modify the original input in order to achieve true rounding.

**Positive Rounding**

With truncation, casting any positive decimal will convert the decimal to the rounded down integer. However, we want decimals less than 0.5 to round down and the rest to round up. To do this, we add 0.5 to the double before casting like so:

```
(int) (a + 0.5);
```

```
Examples:
a = 1.3 which would normally round to 1:
(int) (1.3 + 0.5)
= (int) (1.8)
= **1**
a = 1.8 which would normally round to 2:
(int) (1.8 + 0.5)
= (int) (2.3)
= **2**
a = 1.5 which would normally round to 2:
(int) (1.5 + 0.5)
= (int) (2)
= **2**
a = 1 which would normally round to 1:
(int) (1 + 0.5)
= (int) (1.5)
= **1**
```

**Negative Rounding**

With *truncation*, casting any negative decimal will covert the decimal to the rounded-up integer. However, we want decimals less than 0.5 to round up and the rest to round down. In the same opposite nature, we subtract 0.5 to the double before casting like so:

```
(int) (a - 0.5);
```

```
Examples:
a = -1.3 which would normally round to -1:
(int) (-1.3 - 0.5)
= (int) (-1.8)
= **-1**
a = -1.8 which would normally round to -2:
(int) (-1.8 - 0.5)
= (int) (-2.3)
= -**2**
a = -1.5 which would normally round to -2:
(int) (-1.5 - 0.5)
= (int) (-2)
= -**2**
a = -1 which would normally round to -1:
(int) (-1 - 0.5)
= (int) (-1.5)
= -**1**
```

Take this quiz for a progress check on what youβve learned this year and get a personalized study plan to grab that 5!

START QUIZStudying with Hours = the ultimate focus mode

Start a free study sessionSign up now for instant access to 2 amazing downloads to help you get a 5

Browse Study Guides By Unit

π

Exam Reviews

π±

Unit 10: Recursion

β

Unit 1: Primitive Types

π±

Unit 2: Using Objects

π₯

Unit 3: Boolean Expressions and if Statements

πΉ

Unit 4: Iteration

βοΈ

Unit 5: Writing Classes

βοΈ

Unit 6: Array

πΎ

Unit 7: ArrayList

π»

Unit 8: 2D Array

π²

Unit 9: Inheritance

Thousands of students are studying with us for the AP Computer Science A exam.

join now