Integers

Variables of Integer data type hold whole number values. There are two subtypes of integer data type in Rust, based on the number of bits occupied by a variable in memory.

Fixed Size Types

The fixed integer types have a specific number of bits in their notation. This notation is a combination of a letter and a number. The former denotes the category of the integer, whether it is, unsigned or signed, and the latter denotes the size of an integer, i.e., 8, 16, 32, 64.

Below is the list of fixed length integer types:
- i8: The 8-bit signed integer type.
- i16: The 16-bit signed integer type.
- i32: The 32-bit signed integer type.
- i64: The 64-bit signed integer type.
- u8: The 8-bit unsigned integer type.
- u16: The 16-bit unsigned integer type.
- u32: The 32-bit unsigned integer type.
- u64: The 64-bit unsigned integer type.

Variable Size Types

The integer type in which the particular size depends on the underlying machine architecture.

💡 Why are there so many types of integers and how do you pick a data type? The choice depends on what values a variable is expected to hold. So, a programmer should pick a data type that is not so small that the data is lost. Nor should they pick a data type that is so big that it wastes memory.

isize: The pointer-sized signed integer type. usize: The pointer-sized unsigned integer type

Example

The code below defines an integer type both explicitly and implicitly:

Explicit Definition

The following code explicitly defines the integer variables using the integer type fixed or variable):

fn main() {
    //explicitly define an integer
    let a:i32 = 24;
    let b:u64 = 23;
    let c:usize = 26;
    let d:isize = 29;
    //print the values
    println!("a: {}", a);
    println!("b: {}", b);
    println!("c: {}", c);
    println!("d: {}", d);
    
}

Output

a: 24
b: 23
c: 26
d: 29

Implicit Definition

The following code implicitly defines the integer type of the variable by assigning an integer value to the variable.

fn main() {
    //explicitly define an integer
    let a = 21; 
    let b = 1;
    let c = 54;
    let d = 343434;
    //print the variable
    println!("a: {}", a);
    println!("b: {}", b);
    println!("c: {}", c);
    println!("d: {}", d);
    
}

Output

a: 21
b: 1
c: 54
d: 343434

Floating Point

Floating-point numbers refer to numbers with a fractional part.

The representation of floating-point numbers in a computer’s memory is such that the precision with which a number is stored in memory depends on the number of bits used for storing the variable.

In this respect, there are two subtypes: single-precision f32 and double-precision f64 floating-point, with the latter having more bits to store the number.

f32: The 32-bit floating point type.
f64: The 64-bit floating point type.

Example

The code below defines a floating-point number both explicitly and implicitly:

Explicit Definition

The following code explicitly defines the float variable using the float type (f32 or f64)

fn main() {
    //explicitly define a float type
    let f1:f32 = 32.9;
    let f2:f64 = 6789.89;
    println!("f1: {}", f1);
    println!("f2: {}", f2);
}

Output

f1: 32.9
f2: 6789.89

Implicit Definition

The following code implicitly defines the float type of the variable by assigning a floating-point value to the variable:

fn main() {
    //implicitly define a float type
    let pi = 3.14;
    let e = 2.17828;
    println!("pi: {}", pi);
    println!("e: {}", e);
}

Output

pi: 3.14
e: 2.17828

Quiz

Test your understanding of Numeric Types in Rust!

What is the data type of the variable below?
```
let  a = 123;
```
a) Integer
b) Float
Which of the following is an incorrect notation to declare a float type variable?
a) f32
b) f64
c) f128