fast-factor 0.1.1

A crate with relatively fast functions for factoring unsigned integers
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

# fast-factor

A fast integer factorisation library for unsigned integers in Rust.

## Usage

Add to your `Cargo.toml`:

```toml
[dependencies]
fast-factor = "0.1.1"
```

## Functions

### `factor(n)`
Returns all factors of `n`, including 1 and `n` itself. Returns an empty vector for 0.

```rust
assert_eq!(fast_factor::factor(12_u32), vec![1, 2, 3, 4, 6, 12]);
assert_eq!(fast_factor::factor(1_u32),  vec![1]);
assert_eq!(fast_factor::factor(0_u32),  vec![]);
```

### `proper_factor(n)`
Returns all factors of `n`, excluding `n` itself.

```rust
assert_eq!(fast_factor::proper_factor(12_u32), vec![1, 2, 3, 4, 6]);
assert_eq!(fast_factor::proper_factor(1_u32),  vec![]);
```

### `exclusive_factor(n)`
Returns all factors of `n`, excluding both 1 and `n` itself.

```rust
assert_eq!(fast_factor::exclusive_factor(12_u32), vec![2, 3, 4, 6]);
assert_eq!(fast_factor::exclusive_factor(7_u32),  vec![]);
```

## Generics

All functions are generic over any type implementing `PrimInt + Unsigned + Roots`, so they work with `u8`, `u16`, `u32`, `u64`, `u128`, and `usize`.

```rust
fast_factor::factor(100_u64);
fast_factor::factor(255_u8);
```

## Algorithm

Each function finds factors up to `sqrt(n)` and derives the complementary factors by division, giving O(sqrt(n)) time complexity.

## License

MIT