Floating point types in Rust - Step-by-Step Execution

Concept Flow - Floating point types

Start

↓

Declare float variable

↓

Assign value (e.g., 3.14)

↓

Use variable in calculations

↓

Print or return value

↓

End

This flow shows how a floating point variable is declared, assigned a value, used in calculations, and then output.

Execution Sample

Rust

fn main() {
    let x: f32 = 3.14;
    let y: f64 = 2.718;
    println!("x = {}, y = {}", x, y);
}

This Rust code declares two floating point variables of types f32 and f64, assigns values, and prints them.

Execution Table

Step	Action	Variable	Value	Output
1	Declare x as f32	x	uninitialized
2	Assign 3.14 to x	x	3.14
3	Declare y as f64	y	uninitialized
4	Assign 2.718 to y	y	2.718
5	Print values	x, y	3.14, 2.718	x = 3.14, y = 2.718
6	Program ends

💡 Program ends after printing the floating point values.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
x	uninitialized	3.14	3.14	3.14
y	uninitialized	uninitialized	2.718	2.718

Key Moments - 3 Insights

Why do we specify f32 or f64 when declaring floating point variables?

Rust requires specifying the floating point type to know how much memory to allocate and the precision. See steps 1 and 3 in the execution_table where types are declared.

What happens if we don't assign a value after declaring a variable?

The variable remains uninitialized and cannot be used. In the table, after declaration (steps 1 and 3), values are 'uninitialized' until assigned (steps 2 and 4).

Why are the printed values exactly 3.14 and 2.718?

Because the variables hold those assigned floating point numbers. Step 5 shows the output matching the variable values.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of variable y?

A uninitialized

B 2.718

C 3.14

D 0.0

💡 Hint

Check the 'Value' column for variable y at step 4 in the execution_table.

At which step does the program print the floating point values?

A Step 2

B Step 3

C Step 5

D Step 6

💡 Hint

Look for the 'Print values' action in the execution_table.

If we remove the type f64 from y, what would happen?

A y will default to f64

B y will default to f32

C The program will not compile because type is missing

D The program will print 0.0 for y

💡 Hint

Rust defaults floating point literals to f64 if no type is specified.

Concept Snapshot

Floating point types in Rust:
- Use f32 or f64 to declare floats
- f32 uses 4 bytes, f64 uses 8 bytes
- Default float type is f64
- Assign values with decimal points
- Use println! to display values

Full Transcript

This visual execution shows how floating point types work in Rust. First, variables x and y are declared with types f32 and f64. Initially, they are uninitialized. Then, values 3.14 and 2.718 are assigned. Finally, the program prints these values. The execution table tracks each step, showing variable states and output. Key moments clarify why types are needed and what happens if variables are uninitialized. The quiz tests understanding of variable values at steps and Rust's default float type. This helps beginners see how floating point variables are created, assigned, and used in Rust.