Floating point types in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using f32?

Consider the following Rust code snippet. What will it print?

Rust

fn main() {
    let x: f32 = 0.1 + 0.2;
    println!("{:.8}", x);
}

A 0.30000001

B 0.3

C 0.4

D 0.2

💡 Hint

Remember that floating point numbers can have precision errors.

Adding 0.1 and 0.2 in f32 does not exactly equal 0.3 due to floating point precision. The printed value is slightly off, like 0.30000001.

🧠 Conceptual

intermediate

Which floating point type has higher precision in Rust?

Between f32 and f64 in Rust, which one provides higher precision?

A Both have the same precision

B f64 has higher precision

C f32 has higher precision

D Precision depends on the CPU architecture

💡 Hint

Think about the number of bits used to store each type.

f64 uses 64 bits and provides higher precision than f32, which uses 32 bits.

🔧 Debug

advanced

Why does this Rust code cause a compilation error?

Look at this Rust code snippet. Why does it fail to compile?

Rust

fn main() {
    let x: f32 = 1.0;
    let y: f64 = 2.0;
    let z = x + y;
    println!("{}", z);
}

A f32 and f64 cannot be declared in the same function

B Variables x and y must be mutable to add

C The println! macro does not support floating point numbers

D Cannot add f32 and f64 directly without casting

💡 Hint

Check the types involved in the addition operation.

Rust does not allow adding f32 and f64 directly. You must cast one type to the other before adding.

📝 Syntax

advanced

Which Rust code correctly declares a 64-bit floating point variable?

Choose the correct Rust syntax to declare a variable pi as a 64-bit floating point number with value 3.1415.

A let pi: float64 = 3.1415;

B let pi = 3.1415f32;

C let pi: f64 = 3.1415;

D let pi = f64(3.1415);

💡 Hint

Look at the correct Rust type name for 64-bit floats.

In Rust, f64 is the correct type for 64-bit floating point numbers. The syntax let pi: f64 = 3.1415; is correct.

🚀 Application

expert

What is the value of variable `result` after this Rust code runs?

Analyze the following Rust code and determine the value of result after execution.

Rust

fn main() {
    let a: f64 = 0.1;
    let b: f64 = 0.2;
    let c = a + b;
    let result = (c - 0.3).abs() < 1e-15;
    println!("{}", result);
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Consider floating point precision and how to compare floats safely.

The sum a + b is very close to 0.3 but not exactly equal. The code checks if the difference is less than a tiny number, so result is true.

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