Mathematics in Embedded Rust: A Comprehensive Guide

This section of the Embedded Rust Book explores mathematical operations within embedded systems using the Rust programming language. It emphasizes fundamental math concepts and their application in programming embedded environments.

Key Concepts

Basic Math Operations

• Addition (+): Combines two numbers.
• Subtraction (-): Takes one number away from another.
• Multiplication (*): Repeated addition of a number.
• Division (/): Splits a number into equal parts.

Data Types

Rust features various numeric types, including i32, u32, f32, and f64:

• Signed integers (e.g., i32): Can hold both positive and negative numbers.
• Unsigned integers (e.g., u32): Can only hold positive numbers.
• Floating-point numbers (e.g., f32, f64): Can hold decimal values.

Constants

Use const to define constants that remain unchanged throughout the program.

const PI: f32 = 3.14159;

Math Functions

Rust provides a math library (std::f32 and std::f64) with common functions such as:

• sqrt(): Computes the square root of a number.
• powf(): Raises a number to the power of another.
• round(): Rounds a floating-point number to the nearest integer.

Examples

Basic Example

Performing basic arithmetic:

fn main() {
    let a: i32 = 10;
    let b: i32 = 5;
    
    let sum = a + b;         // Addition
    let difference = a - b;  // Subtraction
    let product = a * b;     // Multiplication
    let quotient = a / b;    // Division

    println!("Sum: {}", sum);
    println!("Difference: {}", difference);
    println!("Product: {}", product);
    println!("Quotient: {}", quotient);
}

Using Constants

Defining and using constants:

const GRAVITY: f32 = 9.81; // Gravitational constant

fn main() {
    let mass: f32 = 10.0; // Mass in kg
    let weight = mass * GRAVITY; // Weight calculation

    println!("Weight: {} N", weight);
}

Using Math Functions

Using the math library:

fn main() {
    let num: f32 = 16.0;
    
    let square_root = num.sqrt(); // Square root function
    let power = num.powf(2.0);     // Power function

    println!("Square root: {}", square_root);
    println!("Power: {}", power);
}

Conclusion

Understanding mathematical operations and concepts is fundamental when programming in Rust for embedded systems. These operations facilitate effective data manipulation and problem-solving across a variety of applications, ranging from simple calculations to complex algorithms.