numy 0.1.0

Trait boundaries for primitive Rust 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

# Numy

Trait boundaries for primitive Rust types.

# Features

Numy contains traits for selection of Rust primitive types, mainly useful for
generic guards.

For example: having a function take a type `T` that is only a numeric value, or
one that takes only floats, or one that takes only signed integers, etc.

To see the provided traits, see [the API's documentation](https://docs.rs/numy).

# Examples

```rust
use numy::{Float, Signed, UnsignedInt};

fn main() {
    foo(1.0_f64);
    bar(-1_i32);
    roy(7_u32);
}

/// Takes only floating point types (`f32` or `f64`).
fn foo<T: Float>(n: T) -> T {
    n.sqrt() * T::PI
}

/// Takes only signed types such as `i32` or `f64`.
fn bar<T: Signed>(n: T) -> T {
    n.abs() + T::ONE
}

/// Takes only unsigned integers such as `u32`.
fn roy<T: UnsignedInt>(n: T) -> T {
    // Note that `T::S` is the signed integer type with the same size as `T`.
    n.wrapping_add_signed(T::S::NEG_ONE)
}
```

`"util"` feature:

```rust
// Requires the `"util"` feature:
use numy::NumUtil;

fn main() {
    assert_eq!(1.abs_diff(3_i32), 2);
    assert_eq!(1.abs_diff(3_u32), 2);
    assert_eq!(1.0.abs_diff(3.0_f64), 2.0);
}

/// Returns the absolute difference of the two values.
fn abs_diff<T: NumUtil>(lhs: T, rhs: T) -> T {
    // `.diff` will never underflow for unsigned integers and `.abs` makes sure
    // signed types yield non-negative results.
    lhs.diff(rhs).abs()
}
```