Floating point types in Rust - Time & Space Complexity

Time Complexity: Floating point types

O(n)

Understanding Time Complexity

When working with floating point types in Rust, it's helpful to understand how operations on these numbers affect program speed.

We want to know how the time to do calculations changes as we work with more floating point numbers.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn sum_floats(numbers: &[f64]) -> f64 {
    let mut total = 0.0;
    for &num in numbers {
        total += num;
    }
    total
}

This code adds up all the floating point numbers in a list and returns the total.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding each floating point number to a running total.
• How many times: Once for each number in the input list.

How Execution Grows With Input

As the list gets longer, the number of additions grows directly with the number of items.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows in a straight line as the input size increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to add all numbers grows directly with how many numbers there are.

Common Mistake

[X] Wrong: "Floating point operations take constant time no matter what, so time complexity doesn't matter."

[OK] Correct: While each addition is fast, doing many additions still takes more time as the list grows, so total time depends on input size.

Interview Connect

Understanding how operations on floating point numbers scale helps you explain performance clearly and shows you can think about efficiency in real code.

Self-Check

"What if we changed the code to multiply all numbers instead of adding? How would the time complexity change?"

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