Casting, Variable Ranges, and Operator Precedence Notes

Definition of Casting: Casting is used to temporarily change the data type of a value and create compatibility among different data types.
Casting Operators:
- (int): Converts a numerical value to an integer.
- (double): Converts a numerical value to a floating-point decimal.
Truncation Behavior: Casting a double value to an int value causes all digits to the right of the decimal point to be truncated (dropped without rounding).
Basic Casting Syntax Examples:
- (int)3.14159: Evaluates to $3$
- (double)3: Evaluates to $3.0$

Data Types and Memory Profiles Involved:
- int: $32\,\text{bit}$ integer
- long: $64\,\text{bit}$ integer
- double: $64\,\text{bit}$ real floating-point number
Initial Variable Declarations:
- int one = 0;
- long big = 453;
- double dec = 7.56;
Illegal Variable Assignments (Require Explicit Narrowing Casts):
- one = dec;: Illegal due to potential loss of decimal precision going from double ( $64\,\text{bit}$ ) to int ( $32\,\text{bit}$ ).
- one = big;: Illegal due to potential loss of capacity going from long ( $64\,\text{bit}$ ) to int ( $32\,\text{bit}$ ).
Legal Variable Assignments (Using Explicit Casting):
- one = (int)dec;: Legal; explicitly converts dec to integer value $7$ .
- one = (int)big;: Legal; explicitly converts big to integer value $453$

Floating-Point Promotion Rule: As long as at least one operand in a division operation is a floating-point decimal value, the resulting operation evaluates to a decimal.
Conversion Sequence in Code:
- Code snippet: int one = 11; int two = 5; double dec = (double)one / two;
- Execution detail: one is temporarily converted to a double ( $11.0$ ) before division takes place, yielding $11.0 / 5 = 2.2$
Code Statements and Expected Output:
- out.println("1/2 = " + (1/2)); -> Outputs 1/2 = 0 (Evaluates integer division $1 / 2 = 0$ )
- out.println("(double)1/2 = " + (double)1/2); -> Outputs (double)1/2 = 0.5 (Casts $1$ to $1.0$ first, then performs $1.0 / 2 = 0.5$ )
- out.println("5/2 = " + (5/2)); -> Outputs 5/2 = 2 (Evaluates integer division $5 / 2 = 2$ )
- out.println("5/(double)2 = " + 5/(double)2); -> Outputs 5/(double)2 = 2.5 (Casts $2$ to $2.0$ first, then performs $5 / 2.0 = 2.5$ )

Purpose of Rounding: Converts values of type double to the nearest whole integer instead of truncating the decimal digits.
Target Results:
- $2.43234$ rounds to $2$
- $4.67384$ rounds to $5$
Algorithm for Non-Negative (Positive) Numbers:
- Mathematical Formula: (int)(x + 0.5)
- Step-by-Step Procedure:
1. Add $0.5$ to the target positive number $x$ .
2. Apply the explicit cast (int) to truncate the remaining fractional digits.
- Step-by-Step Example for $3.3$ :
1. Add $0.5$ : $3.3 + 0.5 = 3.8$
2. Perform cast: (int)3.8 = $3$
- Java Implementation Example:
- Code: double d = 9.25; int i = (int)(d + 0.5); System.out.println(i);
- Result: Outputs $9$
Algorithm for Negative Numbers:
- Mathematical Formula: (int)(x - 0.5)
- Step-by-Step Procedure: Subtract $0.5$ from the negative number $x$ , then apply an (int) cast.

Definition of Integer Overflow Error: Occurs when an arithmetic expression evaluates to an int value outside of its allowed representable range.
Consequences: The evaluation wraps around and produces an int value within the allowed range, but it will not match the expected mathematical result.

Definition of Round-Off Error:
- Computers allocate a specified, fixed amount of memory to store data based on data type.
- If an expression evaluates to a double value that is more precise than can be stored in the allotted memory, a round-off error occurs.
Outcome: The calculated value is rounded automatically to the nearest representable value.
Mitigation Strategy: To avoid round-off errors that naturally occur in floating-point operations, use int values.

Primitive Type Specifications:
- byte:
- Memory Usage: $8\,\text{bits}$
- Value Range: $-128$ to $127$
- short:
- Memory Usage: $16\,\text{bits}$
- Value Range: $-32768$ to $32767$
- int:
- Memory Usage: $32\,\text{bits}$
- Value Range: $-2 \times 10^9$ to $2 \times 10^9$ ( $-2\,\text{billion}$ to $2\,\text{billion}$ )
- long:
- Memory Usage: $64\,\text{bits}$
- Value Range: $- \text{big}$ to $+ \text{big}$
- float:
- Memory Usage: $32\,\text{bits}$
- Value Range: $- \text{big}$ to $+ \text{big}$
- double:
- Memory Usage: $64\,\text{bits}$
- Value Range: $- \text{big}$ to $+ \text{big}$
- char:
- Memory Usage: $16\,\text{bit unsigned}$
- Value Range: $0$ to $65535$
- boolean:
- Memory Usage: $1\,\text{bit}$
- Allowed Values: true or false
General Requirement: Knowing all data types and what each one can store is essential for precise program construction.