Why Floating point types in Rust? - Purpose & Use Cases

The Big Idea

What if your calculator could only add whole numbers? Discover how floating point types fix that!

The Scenario

Imagine you want to calculate the average score of your friends in a game, but you try to do it using only whole numbers. You quickly realize that you lose the decimal parts, making your results less accurate.

The Problem

Using only whole numbers means you can't represent fractions or decimals. This makes calculations like averages, measurements, or money amounts inaccurate and frustrating. You might get wrong results or have to do complicated workarounds.

The Solution

Floating point types let you store numbers with decimals, so you can represent values like 3.14 or 0.001 easily. This makes math with fractions simple and accurate enough for many real-world uses.

Before vs After

✗ Before

let sum = 7 + 8; let average = sum / 2; // average is 7, not 7.5

✓ After

let sum = 7.0 + 8.0; let average = sum / 2.0; // average is 7.5

What It Enables

With floating point types, you can handle precise measurements, scientific calculations, and smooth animations that need decimal numbers.

Real Life Example

Calculating the distance between two GPS points requires decimals because locations are not whole numbers. Floating point types make this possible.

Key Takeaways

Whole numbers can't represent fractions well.

Floating point types store decimal numbers efficiently.

This helps with accurate calculations in many real-world tasks.

Practice

1. Which floating point type is the default in Rust when you write a decimal number like 3.14?

easy

A. double

B. f32

C. float

D. f64

Solution

1. Step 1: Understand Rust's default floating point type

   Rust uses f64 as the default floating point type for decimal numbers for better precision.

2. Step 2: Compare with other types

   f32 is less precise and not the default; float and double are not Rust types.

3. Final Answer:

   f64 -> Option D

4. Quick Check:

   Default floating point type = f64 [OK]

Hint: Remember: Rust defaults to f64 for decimals [OK]

Common Mistakes:

• Confusing f32 as default
• Using non-Rust types like float or double
• Assuming integers are default for decimals

2. Which of the following is the correct way to declare a 32-bit floating point variable named num with value 5.5 in Rust?

easy

A. let num = 5.5 f32;

B. let num: f32 = 5.5f32;

C. let num: float = 5.5;

D. let num = 5.5f64;

Solution

1. Step 1: Check Rust syntax for f32 declaration

   Declaring a variable with type f32 uses let num: f32 = 5.5f32;.

2. Step 2: Validate other options

   let num = 5.5 f32; is invalid syntax (should be 5.5f32 without space). let num: float = 5.5; uses float which is not a Rust type. let num = 5.5f64; declares f64, not f32.

3. Final Answer:

   let num: f32 = 5.5f32; -> Option B

4. Quick Check:

   Correct f32 declaration = let num: f32 = 5.5f32; [OK]

Hint: Use let var: f32 = value; for 32-bit floats [OK]

Common Mistakes:

• Using non-existent type 'float'
• Mixing f32 and f64 suffixes incorrectly
• Omitting type when specific precision is needed

3. What will be the output of this Rust code?

let x = 1.0; // f64 by default
let y: f32 = 2.0f32;
println!("{}", x + y as f64);

medium

A. 3.0

B. 3

C. Error: mismatched types

D. 3.00

Solution

1. Step 1: Understand type casting in the expression

   Variable y is f32, but it is cast to f64 with y as f64 before addition.

2. Step 2: Calculate the sum and output format

   Adding 1.0 (f64) and 2.0 (f64) results in 3.0. The println! macro prints it as 3.0 when using {} with floating point numbers.

3. Final Answer:

   3.0 -> Option A

4. Quick Check:

   println!("{}", 1.0 + 2.0f32 as f64) = 3.0 [OK]

Hint: Cast f32 to f64 before adding to avoid errors [OK]

Common Mistakes:

• Not casting f32 to f64 causing type errors
• Expecting integer output instead of float
• Confusing output format with extra zeros

4. Identify the error in this Rust code snippet:

let a: f32 = 3.5f32;
let b: f64 = 4.5;
let c = a + b;

medium

A. Cannot add f32 and f64 without casting

B. Variable c is not declared with a type

C. f32 cannot hold decimal values

D. Missing semicolon after let b

Solution

1. Step 1: Check types of variables a and b

   Variable a is f32, and b is f64. Rust does not allow direct arithmetic between different float types.

2. Step 2: Identify the error in addition

   Adding a + b causes a type mismatch error. One must cast either a or b to the other's type before adding.

3. Final Answer:

   Cannot add f32 and f64 without casting -> Option A

4. Quick Check:

   Mixing f32 and f64 needs casting [OK]

Hint: Always cast floats to same type before arithmetic [OK]

Common Mistakes:

• Ignoring type mismatch between f32 and f64
• Assuming implicit conversion happens
• Thinking missing semicolon causes error here

5. You want to store the average of three numbers: 4.2, 5.8, and 6.0 in Rust with the highest precision. Which code snippet correctly does this?

hard

A. let avg = (4.2f32 + 5.8f32 + 6.0f32) / 3.0f32;

B. let avg = (4.2 + 5.8 + 6.0) / 3f32;

C. let avg: f64 = (4.2 + 5.8 + 6.0) / 3.0;

D. let avg: f32 = (4.2 + 5.8 + 6.0) / 3.0;

Solution

1. Step 1: Choose the highest precision floating point type

   Rust's f64 provides higher precision than f32, so declaring avg as f64 is best.

2. Step 2: Check the expression and types

   Using decimal literals without suffix defaults to f64. Dividing by 3.0 (also f64) keeps precision. let avg: f64 = (4.2 + 5.8 + 6.0) / 3.0; correctly declares avg: f64 and uses f64 literals.

3. Final Answer:

   let avg: f64 = (4.2 + 5.8 + 6.0) / 3.0; -> Option C

4. Quick Check:

   Use f64 for highest precision average [OK]

Hint: Use f64 and decimal literals without suffix for precision [OK]

Common Mistakes:

• Using f32 when higher precision is needed
• Dividing by integer 3 causing integer division
• Mixing types without explicit declaration