fixed32-math 0.0.19

Geometric types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

# Fixed32 Math

`fixed32_math` is a Rust crate that provides efficient 2D vector and rectangle operations
using fixed-point arithmetic. Designed for applications where fixed precision is preferred,
this crate is ideal for scenarios such as graphics programming,
game development, and embedded systems where deterministic results are crucial.

## Overview

### Vector

The `Vector` struct represents a 2D vector and supports various operations including addition,
subtraction, scaling, normalization, and more. The vector components use fixed-point arithmetic
via the `fixed32` crate.

#### Example Usage

```rust
use fixed32::Fp;
use fixed32_math::Vector;

// Create vectors using the `From` trait
let v1 = Vector::from((2, 3));  // Automatically converts (2, 3) to Vector with Fp::from
let v2 = Vector::from((1, 4));

// Vector operations
let sum = v1 + v2;
let dot_product = v1.dot(&v2);
let normalized = v1.normalize().unwrap();
let rotated = v1.rotate(Fp::from(90).to_radians());
```

### Rect

The `Rect` struct represents an axis-aligned rectangle defined by its lower left position and size.
It supports operations such as intersection, union, expansion, and contraction, as well as checking
if a point or another rectangle is contained within it.

#### Example Usage

```rust
use fixed32::Fp;
use fixed32_math::{Vector, Rect};

// Create Rect instances using `From` trait
let rect1 = Rect::from((0, 0, 10, 10));
let rect2 = Rect::from((5, 5, 15, 15));

// Rectangle operations
let intersection = rect1.intersection(&rect2);
let union = rect1.union(&rect2);
let contains_point = rect1.contains_point(&Vector::from((2, 2)));
let expanded_rect = rect1.expanded(Vector::from((2, 2)));
```

#### Using `From` Trait

The `From` trait is implemented for convenient creation of `Rect` and `Vector` from tuples of integers:

```rust
// Create a Rect from a tuple of integers
let rect = Rect::from((1, 2, 3, 4));

let rect2 = Rect::from((1.24, 2.34, 3.98, 4.01));

// Create a Vector from a tuple of integers
let vector = Vector::from((2, 2));
```

This feature allows you to create `Rect` and `Vector` instances in a more concise manner without needing to
manually convert integer and float values to fixed-point numbers (`fixed32::Fp`).

## Features

- **Fixed-Point Arithmetic**: Uses `fixed32::Fp` for all calculations, avoiding floating-point inaccuracies.
- **Comprehensive Operations**: Includes basic arithmetic operations, normalization, rotation, and more for vectors.
- **Rectangle Operations**: Includes area, perimeter, intersection, union, and containment checks for rectangles.

## Installation

Add the following to your `Cargo.toml`:

```toml
[dependencies]
fixed32_math = "0.0.16"
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.