Floating point types in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a 32-bit floating point variable.

Rust

let pi: [1] = 3.14f32;

Drag options to blanks, or click blank then click option'

Achar

Bi32

Cbool

Df32

Attempts:

3 left

💡 Hint

Common Mistakes

Using integer types like i32 for floating point numbers.

Using boolean or character types for numbers.

The f32 type is used for 32-bit floating point numbers in Rust.

2fill in blank

medium

Complete the code to declare a 64-bit floating point variable.

Rust

let e: [1] = 2.71828;

Drag options to blanks, or click blank then click option'

Ausize

Bi64

Cf64

Dbool

Attempts:

3 left

💡 Hint

Common Mistakes

Using integer types like i64 instead of floating point.

Confusing usize with floating point types.

The f64 type is used for 64-bit floating point numbers in Rust.

3fill in blank

hard

Fix the error in the code by choosing the correct floating point type.

Rust

let gravity: [1] = 9.81;

Drag options to blanks, or click blank then click option'

Af64

Bf128

Cint

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent types like f128 or int.

Using string types for numbers.

Rust supports f32 and f64 for floating point types. f64 is the correct 64-bit type.

4fill in blank

hard

Fill both blanks to create a vector of 32-bit floating point numbers.

Rust

let numbers: Vec<[1]> = vec![1.0f32, 2.0f32, 3.0f32];
let first: [2] = numbers[0];

Drag options to blanks, or click blank then click option'

Af32

Bi32

Cf64

Dbool

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing integer and floating point types.

Using f64 when the vector is f32.

The vector holds f32 values, so the variable first must also be f32.

5fill in blank

hard

Fill all three blanks to create a function that returns a 64-bit floating point number.

Rust

fn calculate_area(radius: [1]) -> [2] {
    let pi: [3] = 3.14159;
    pi * radius * radius
}

Drag options to blanks, or click blank then click option'

Af32

Bf64

Di32

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing f32 and f64 types.

Using integer types for floating point calculations.

The function uses f64 for the parameter, return type, and constant pi for precision.

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