ndimpoint 0.2.1

A library for working with N-dimensional points in Rust.
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

# N-Dimensional Point Library

A simple, generic N-dimensional point library in Rust. This library provides a `Point` struct that can be used to represent points in an N-dimensional space. It supports various mathematical operations like addition, subtraction, multiplication, and division for both point-point and point-scalar operations.

## Features

  - **Generic N-dimensional Point:** Create points of any dimension with any numeric type.
  - **Basic Point Operations:**
      - `new(p: Vec<T>)`: Creates a new point.
      - `dim() -> usize`: Returns the dimension of the point.
      - `dist() -> f64`: Calculates the Euclidean distance from the origin.
      - `apply(func: F) -> f64`: Applies a custom function to the point's data.
      - `data() -> &[T]`: Returns a slice of the point's data.
  - **Operator Overloading:** Intuitive arithmetic operations.
      - **Point-Point Operations:** `+`, `-`, `*`
      - **Scalar Operations:** `+`, `-`, `*`, `/`
  - **Ownership and Borrowing:** Operations are implemented for both owned types (`Point<T>`) and references (`&Point<T>`).

-----

## Getting Started

### Creating a Point

You can create a new `Point` from a `Vec<T>`, where `T` is a numeric type.

```rust
use crate::Point;

// Create a 3-dimensional point with integer coordinates
let p1 = Point::new(vec![1, 2, 3]);

// Create a 2-dimensional point with float coordinates
let p2 = Point::new(vec![1.5, 2.5]);
```

-----

## Usage

### Basic Methods

Here are some of the basic methods available for `Point` instances:

```rust
// Get the dimension of the point
println!("Dimension of p1: {}", p1.dim()); // Output: 3

// Calculate the distance from the origin
println!("Distance of p1 from origin: {}", p1.dist()); // Output: 3.7416573867739413

// Get a slice of the point's data
let data = p1.data();
println!("Data of p1: {:?}", data); // Output: [1, 2, 3]

// Apply a custom function to the point's data
let sum = p1.apply(|coords| coords.iter().sum::<i32>() as f64);
println!("Sum of p1's coordinates: {}", sum); // Output: 6.0
```

-----

### Point Arithmetic

The library supports arithmetic operations between points of the same dimension.

```rust
let p1 = Point::new(vec![1, 2, 3]);
let p2 = Point::new(vec![4, 5, 6]);

// Addition
let p_add = &p1 + &p2;
println!("p1 + p2 = {:?}", p_add.data()); // Output: [5, 7, 9]

// Subtraction
let p_sub = &p1 - &p2;
println!("p1 - p2 = {:?}", p_sub.data()); // Output: [-3, -3, -3]

// Multiplication (element-wise)
let p_mul = &p1 * &p2;
println!("p1 * p2 = {:?}", p_mul.data()); // Output: [4, 10, 18]
```

-----

### Scalar Arithmetic

You can also perform arithmetic operations between a `Point` and a scalar value.

```rust
let p = Point::new(vec![1, 2, 3]);

// Scalar Addition
let p_add_scalar = &p + 10;
println!("p + 10 = {:?}", p_add_scalar.data()); // Output: [11, 12, 13]

// Scalar Subtraction
let p_sub_scalar = &p - 5;
println!("p - 5 = {:?}", p_sub_scalar.data()); // Output: [-4, -3, -2]

// Scalar Multiplication
let p_mul_scalar = &p * 2;
println!("p * 2 = {:?}", p_mul_scalar.data()); // Output: [2, 4, 6]

// Scalar Division
let p_div_scalar = &Point::new(vec![10, 20, 30]) / 10;
println!("[10, 20, 30] / 10 = {:?}", p_div_scalar.data()); // Output: [1, 2, 3]
```

-----

## Testing

To run the tests and verify that everything is working correctly, you can use the following command:

```bash
cargo test
```