big_num_math 6.0.0

Unostentatious library for computations on large numbers.
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

### BIG NUM MATH
Library for computations on large numbers.

- development notes: 
    1. upcomming functions: greatest common divisor
    2. planned optimizations (memory consumption [half memory requirement])
- functions only:
    - addition +substraction, 
    - multiplication +division (with remainder)
    - relation and decimal relation operators
    - order of magnitude
    - power +nth root
    - integer square root
    - primality check
    - prime number generator (primitive number types only)

### Usage Samples

##### power

```rust
let row = PlacesRow::new_from_u128(u128::MAX);
let pow = pow(&row, 500);
let number = pow.to_number();

assert!(number.starts_with("8312324609993336522"));
assert_eq!(19266, number.len());
```

##### division with remainder

```rust
let dividend = PlacesRow::new_from_str("3402823669209384634633746074317682114565556668744123").unwrap();
let divisor  = PlacesRow::new_from_str(  "14034568236692093846346337460345176821145655563453").unwrap();
let ratio = "242";        
let remainder = "6458155929897923817932408914149323848308022388497";
        
let ratrem = divrem(&dividend, &divisor).unwrap();
        
assert_eq!(ratio, ratrem.0.to_number());
assert_eq!(remainder, ratrem.1.to_number());
```

```rust
let dividend = Row::new_from_str("99999340282366920938463463374607431768211455").unwrap();
let divisor  = Row::new_from_usize(249);

let ratio     = Row::new_from_str("401603776234405304973748848894005750073138").unwrap();
let remainder = Row::new_from_usize(93);

let ratrem = divrem(&dividend, &divisor).unwrap();
assert_eq!(ratio, ratrem.0);
assert_eq!(remainder, ratrem.1);
```

##### decimal places relation

```rust
let number    = Row::new_from_str("1489754132134687989463132131").unwrap();
let comparand = Row::new_from_str(        "48645698946456531371").unwrap();
let decrel = rel_dec(&number, &comparand);

assert_eq!(RelDec::Greater((28, 20, 8)), decrel);
```

##### order of magnitude

```rust
let number_1 = PlacesRow::new_from_u128(3162277660168379331998893544432);
let number_2 = PlacesRow::new_from_u128(3162277660168379331998893544433);

assert_eq!(Oom::Precise(30), ord_of_mag(&number_1, OomClass::Strict));
assert_eq!(Oom::Precise(31), ord_of_mag(&number_2, OomClass::Strict));
assert_eq!(Oom::Precise(30), ord_of_mag(&number_2, OomClass::Loose));
```

##### square root

```rust
let radicand  = Row::new_from_str("9754610577924096936222542295378750190521").unwrap();
let test = Row::new_from_u128(98_765_432_100_123_456_789);
assert_eq!(test, heron_sqrt(&radicand));
```
##### primality check

```rust
let num = Row::new_from_str("340282366920938463463374607431768211479").unwrap();
let limit = Duration::from_secs(3);
assert_eq!(Some(false), prime_ck(&num, Some(limit)));
```

##### prime number generation

```rust
let limit = Duration::from_secs(60);
let p = || pg!(200_000, PrimeGenStrain::Nth, false, u32, Some(limit));
assert_eq!(Ok(PrimeGenRes::Max(2_750_159)), p());
```
##### nth  root

```rust
let test = PlacesRow::new_from_usize(99_999_999);
let radicand = PlacesRow::new_from_str(
    "999999910000003599999916000001259999987400000083999999640000000899999999",
)
.unwrap();
assert_eq!(Some(test), root(&radicand, 9));
```