Arithmetic Operations

In Rust programming, arithmetic operations play a fundamental role in manipulating data. Rust provides a standard set of arithmetic operators, including addition, subtraction, multiplication, division, and the modulo operator, allowing for versatile computation capabilities.

Let's explore these arithmetic operations in Rust with examples:

1. Addition (+):

let a = 10;
let b = 3;
let c = a + b; // c = 13

2. Subtraction (-):

let a = 10;
let b = 3;
let c = a - b; // c = 7

3. Multiplication (*):

let a = 10;
let b = 3;
let c = a * b; // c = 30

4. Division (/):

let a = 10;
let b = 3;
let c = a / b; // c = 3 (truncates the fractional part)

5. Modulo (%):

let a = 10;
let b = 3;
let c = a % b; // c = 1 (remainder of 10 divided by 3)

When performing division operations with floating-point values, the result retains decimal precision:

let a = 10.0;
let b = 3.0;
let c = a / b; // c = 3.3333...

Mixing different data types in arithmetic operations requires explicit casting:

let a = 10; // Integer
let b = 3.0; // Float
let c = a as f64 / b; // Cast integer to float before division

or

let a = 10; // Integer
let b = 3.0; // Float
let c = a / b as i32; // Cast float to integer before division

Casting between data types can lead to loss of information, depending on the types involved:

let d = 3.9 as i32; // d = 3 (fractional part truncated)
let e = 300 as u8; // e = 44 (overflow, extra rolls over)

Rust respects the order of precedence in arithmetic operations, executing multiplication, division, and modulo before addition and subtraction:

let a = 10;
let b = 3;
let c = a / b + 1; // c = 4 (division first, then addition)

To control the order of evaluation, use parentheses to specify precedence:

let c = (a / (b + 1)) as f64; // c = 2.5 (addition first, then division)

Understanding arithmetic operations and their nuances in Rust is essential for writing efficient and reliable code. By mastering these fundamentals, Rust programmers can confidently tackle a wide range of computational tasks.