random_examples/
random_examples.rs

1// Copyright 2023, 2024 PARK Youngho.
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
6// This file may not be copied, modified, or distributed
7// except according to those terms.
8
9// #![allow(missing_docs)]
10// #![allow(rustdoc::missing_doc_code_examples)]
11// #[allow(non_camel_case_types)]
12
13
14pub fn main()
15{
16    random_quick_start();
17    random_new();
18    random_new_with_seeds();
19    random_random_u8();
20    random_random_u16();
21    random_random_u32();
22    random_random_u64();
23    random_random_u128();
24    random_random_usize();
25    random_random_uint();
26    random_random_under_uint();
27    random_random_under_uint_();
28    random_random_minmax_uint();
29    random_random_minmax_uint_();
30    random_random_odd_uint();
31    random_random_odd_under_uint();
32    random_random_odd_under_uint_();
33    random_random_with_msb_set_uint();
34    random_random_odd_with_msb_set_uint();
35    random_random_prime_using_miller_rabin_uint();
36    random_random_prime_with_msb_set_using_miller_rabin_uint();
37    random_random_array();
38    random_put_random_array();
39    random_random_biguint();
40    random_random_under_biguint();
41    random_random_under_biguint_();
42    random_random_odd_biguint();
43    random_random_odd_under_biguint();
44    random_random_odd_under_biguint_();
45    random_random_with_msb_set_biguint();
46    random_random_odd_with_msb_set_biguint();
47    random_random_prime_using_miller_rabin_biguint();
48    random_random_prime_with_msb_set_using_miller_rabin_biguint();
49}
50
51fn random_quick_start()
52{
53    println!("random_quick_start");
54    use cryptocol::random::Random;
55    use cryptocol::define_utypes_with;
56    define_utypes_with!(u64);
57
58    let mut rand = Random::new();
59    println!("Random number = {}", rand.random_u128());
60    println!("Random number = {}", rand.random_u64());
61    println!("Random number = {}", rand.random_u32());
62    println!("Random number = {}", rand.random_u16());
63    println!("Random number = {}", rand.random_u8());
64
65    if let Some(num) = rand.random_under_uint(1234567890123456_u64)
66        { println!("Random number u64 = {}", num); }
67
68    if let Some(num) = rand.random_minmax_uint(1234_u16, 6321)
69        { println!("Random number u16 = {}", num); }
70
71    println!("Random odd number usize = {}", rand.random_odd_uint::<usize>());
72    if let Some(num) = rand.random_odd_under_uint(1234_u16)
73        { println!("Random odd number u16 = {}", num); }
74
75    println!("Random 128-bit number u128 = {}", rand.random_with_msb_set_uint::<u128>());
76    println!("Random 16-bit odd number u16 = {}", rand.random_with_msb_set_uint::<u16>());
77    println!("Random prime number u64 = {}", rand.random_prime_using_miller_rabin_uint::<u64>(5));
78    println!("Random usize-sized prime number usize = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<usize>(5));
79
80    let num: [u128; 20] = rand.random_array();
81    for i in 0..20
82        { println!("Random number {} => {}", i, num[i]); }
83
84    let mut num = [0_u64; 32];
85    rand.put_random_in_array(&mut num);
86    for i in 0..32
87        { println!("Random number {} => {}", i, num[i]); }
88
89    let mut biguint: U512 = rand.random_biguint();
90    println!("Random Number: {}", biguint);
91
92    let mut ceiling = U1024::max().wrapping_div_uint(3_u8);
93    if let Some(r) = rand.random_under_biguint(&ceiling)
94    {
95        println!("Random Number less than {} is\n{}", ceiling, r);
96        assert!(r < ceiling);
97    }
98
99    ceiling = U1024::max().wrapping_div_uint(5_u8);
100    let r = rand.random_under_biguint_(&ceiling);
101    println!("Random Number less than {} is\n{}", ceiling, r);
102    assert!(r < ceiling);
103
104    ceiling = U1024::max().wrapping_div_uint(4_u8);
105    if let Some(r) = rand.random_odd_under_biguint(&ceiling)
106    {
107        println!("Random odd Number less than {} is\n{}", ceiling, r);
108        assert!(r < ceiling);
109    }
110
111    biguint = rand.random_with_msb_set_biguint();
112    println!("Random Number: {}", biguint);
113
114    biguint = rand.random_odd_with_msb_set_biguint();
115    println!("512-bit Random Odd Number = {}", biguint);
116    assert!(biguint > U512::halfmax());
117    assert!(biguint.is_odd());
118
119    biguint = rand.random_prime_using_miller_rabin_biguint(5);
120    println!("Random Prime Number = {}", biguint);
121    assert!(biguint.is_odd());
122
123    biguint = rand.random_prime_with_msb_set_using_miller_rabin_biguint(5);
124    println!("512-bit Random Prime Number = {}", biguint);
125    assert!(biguint.is_odd());
126    println!("-------------------------------");
127}
128
129fn random_new()
130{
131    println!("random_new");
132    // Example for Random
133    use cryptocol::random::Random;
134    let mut rand = Random::new();
135    println!("Random number = {}", rand.random_u128());
136
137    // Example for Any
138    use cryptocol::random::Any;
139    let mut any = Any::new();
140    println!("Any number = {}", any.random_u64());
141
142    // Example for Any_Num
143    use cryptocol::random::Any_Num;
144    let mut any_num = Any_Num::new();
145    println!("Any number = {}", any_num.random_u32());
146
147    // Example for Any_Num_C
148    use cryptocol::random::Any_Num_C;
149    let mut any_num_c = Any_Num_C::new();
150    println!("Any number = {}", any_num_c.random_u16());
151
152    // Example for Any_MD4
153    use cryptocol::random::Any_MD4;
154    let mut any_md4 = Any_MD4::new();
155    println!("Any number = {}", any_md4.random_u8());
156
157    // Example for Any_MD5
158    use cryptocol::random::Any_MD5;
159    let mut any_md5 = Any_MD5::new();
160    println!("Any number = {}", any_md5.random_usize());
161
162    // Example for Any_SHA0
163    use cryptocol::random::Any_SHA0;
164    let mut any_sha0 = Any_SHA0::new();
165    println!("Any number = {}", any_sha0.random_uint::<u8>());
166
167    // Example for Any_SHA1
168    use cryptocol::random::Any_SHA1;
169    let mut any_sha1 = Any_SHA1::new();
170    if let Some(num) = any_sha1.random_under_uint(1234_u16)
171        { println!("Any number = {}", num); }
172
173    // Example for Any_SHA2_256
174    use cryptocol::random::Any_SHA2_256;
175    let mut any_sha2_256 = Any_SHA2_256::new();
176    if let Some(num) = any_sha2_256.random_minmax_uint(12345678_u32, 87654321)
177        { println!("Any number = {}", num); }
178
179    // Example for Any_SHA2_512
180    use cryptocol::random::Any_SHA2_512;
181    let mut any_sha2_512 = Any_SHA2_512::new();
182    println!("Any odd number = {}", any_sha2_512.random_odd_uint::<u64>());
183
184    // Example for Random_SHA2_512
185    use cryptocol::random::Random_SHA2_512;
186    let mut random_sha2_512 = Random_SHA2_512::new();
187    println!("Random prime number = {}", random_sha2_512.random_prime_using_miller_rabin_uint::<u128>(5));
188
189    // Example for Random_Generic
190    use cryptocol::random::Random_Generic;
191    use cryptocol::hash::MD4_Expanded;
192    type MyMD4 = MD4_Expanded<4, 0x1111_1111, 0x4444_4444, 0x8888_8888, 0xffff_ffff, 96>;
193    let mut any_md4_expanded = Random_Generic::<1000>::new_with(MyMD4::new(), MyMD4::new());
194    println!("Any number = {}", any_md4_expanded.random_biguint::<u128, 4>());
195    println!("-------------------------------");
196}
197
198fn random_new_with_seeds()
199{
200    println!("random_new_with_seeds");
201    // Example for Random
202    use cryptocol::random::Random;
203    let mut rand = Random::new_with_seeds(10500872879054459758_u64, 15887751380961987625_u64);
204    println!("Random number = {}", rand.random_u8());
205
206    // Example for Any
207    use cryptocol::random::Any;
208    let mut any = Any::new_with_seeds(100, 25);
209    println!("Any number = {}", any.random_u16());
210
211    // Example for Any_Num
212    use cryptocol::random::Any_Num;
213    let mut any_num = Any_Num::new_with_seeds(50558, 18782);
214    println!("Any number = {}", any_num.random_u32());
215
216    // Example for Any_Num_C
217    use cryptocol::random::Any_Num_C;
218    let mut any_num_c = Any_Num_C::new_with_seeds(458861005, 793621585);
219    println!("Any number = {}", any_num_c.random_u64());
220
221    // Example for Any_MD4
222    use cryptocol::random::Any_MD4;
223    let mut any_md4 = Any_MD4::new_with_seeds(106842379157284697, 18446744073709551615);
224    println!("Any number = {}", any_md4.random_usize());
225
226    // Example for Any_MD5
227    use cryptocol::random::Any_MD5;
228    let mut any_md5 = Any_MD5::new_with_seeds(58, 161);
229    println!("Any number = {}", any_md5.random_u128());
230
231    // Example for Any_SHA0
232    use cryptocol::random::Any_SHA0;
233    let mut any_sha0 = Any_SHA0::new_with_seeds(0, 125);
234    println!("Any prime number = {}", any_sha0.random_prime_using_miller_rabin_uint::<u128>(5));
235
236    // Example for Any_SHA1
237    use cryptocol::random::Any_SHA1;
238    let mut any_sha1 = Any_SHA1::new_with_seeds(18782, 50558);
239    println!("Any number = {}", any_sha1.random_uint::<u8>());
240
241    // Example for Any_SHA2_256
242    use cryptocol::random::Any_SHA2_256;
243    let mut any_sha2_256 = Any_SHA2_256::new_with_seeds(610458805, 215793685);
244    if let Some(num) = any_sha2_256.random_under_uint(1234_u16)
245        { println!("Any number = {}", num); }
246
247    // Example for Any_SHA2_512
248    use cryptocol::random::Any_SHA2_512;
249    let mut any_sha2_512 = Any_SHA2_512::new_with_seeds(2879054410500759758, 15887876257513809619);
250    if let Some(num) = any_sha2_512.random_minmax_uint(12345678_u32, 87654321)
251        { println!("Any number = {}", num); }
252
253    // Example for Random_SHA2_512
254    use cryptocol::random::Random_SHA2_512;
255    let mut random_sha2_512 = Random_SHA2_512::new_with_seeds(15698731215687456325, 10684237915728469725);
256    println!("Random odd number = {}", random_sha2_512.random_odd_uint::<u128>());
257
258    // Example for Random_Generic
259    use cryptocol::random::Random_Generic;
260    use cryptocol::hash::MD5_Expanded;
261    type MyMD5 = MD5_Expanded<4, 0x1111_1111, 0x4444_4444, 0x8888_8888, 0xffff_ffff, 96>;
262    let mut any_md5_expanded = Random_Generic::<123456789>::new_with_generators_seeds(MyMD5::new(), MyMD5::new(), 6445332556087625, 43057945771605458);
263    println!("Any number = {}", any_md5_expanded.random_biguint::<u64, 8>());
264    println!("-------------------------------");
265}
266
267fn random_random_u8()
268{
269    println!("random_random_u8");
270    // Example for Random
271    use cryptocol::random::Random;
272    let mut rand = Random::new();
273    for i in 0..10
274        { println!("{} Random number (Random) = {}", i, rand.random_u8()); }
275
276    // Example for Any
277    use cryptocol::random::Any;
278    let mut any = Any::new();
279    for i in 0..10
280        { println!("{} Any number (Any) = {}", i, any.random_u8()); }
281  
282    // Example for Any_Num
283    use cryptocol::random::Any_Num;
284    let mut any_num = Any_Num::new();
285    for i in 0..10
286        { println!("{} Any number (Any_Num) = {}", i, any_num.random_u8()); }
287
288    // Example for Any_Num_C
289    use cryptocol::random::Any_Num_C;
290    let mut any_num_c = Any_Num_C::new();
291    for i in 0..10
292        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_u8()); }
293
294    // Example for Any_MD4
295    use cryptocol::random::Any_MD4;
296    let mut any_md4 = Any_MD4::new();
297    for i in 0..10
298        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_u8()); }
299
300    // Example for Any_MD5
301    use cryptocol::random::Any_MD5;
302    let mut any_md5 = Any_MD5::new();
303    for i in 0..10
304        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_u8()); }
305
306    // Example for Any_SHA0
307    use cryptocol::random::Any_SHA0;
308    let mut any_sha0 = Any_SHA0::new();
309    for i in 0..10
310        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_u8()); }
311
312    // Example for Any_SHA1
313    use cryptocol::random::Any_SHA1;
314    let mut any_sha1 = Any_SHA1::new();
315    for i in 0..10
316        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_u8()); }
317
318    // Example for Any_SHA2_256
319    use cryptocol::random::Any_SHA2_256;
320    let mut any_sha2_256 = Any_SHA2_256::new();
321    for i in 0..10
322        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_u8()); }
323
324    // Example for Any_SHA2_512
325    use cryptocol::random::Any_SHA2_512;
326    let mut any_sha2_512 = Any_SHA2_512::new();
327    for i in 0..10
328        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_u8()); }
329
330    // Example for Random_SHA2_512
331    use cryptocol::random::Random_SHA2_512;
332    let mut rand_sha2_512 = Random_SHA2_512::new();
333    for i in 0..10
334        { println!("{} Random number (Any_SHA2_512) = {}", i, rand_sha2_512.random_u8()); }
335
336    // Example for Random_Generic
337    use cryptocol::random::Random_Generic;
338    use cryptocol::hash::SHA0_Expanded;
339    type MySHA0 = SHA0_Expanded<5, 0x1111_1111, 0x4444_4444, 0x8888_8888, 0xcccc_cccc, 0xffff_ffff, 160>;
340    let mut any_sha0_expanded = Random_Generic::<1000000000>::new_with_generators_seeds(MySHA0::new(), MySHA0::new(), 6445332556087625_u64, 43057945771605458_u64);
341    for i in 0..10
342        { println!(" {} Any number (Any_SHA2_512) = {}", i, any_sha0_expanded.random_u8()); }
343    println!("-------------------------------");
344}
345
346fn random_random_u16()
347{
348    println!("random_random_u16");
349    // Example for Random
350    use cryptocol::random::Random;
351    let mut rand = Random::new();
352    for i in 0..10
353        { println!("{} Random number (Random) = {}", i, rand.random_u16()); }
354
355    // Example for Any
356    use cryptocol::random::Any;
357    let mut any = Any::new();
358    for i in 0..10
359        { println!("{} Any number (Any) = {}", i, any.random_u16()); }
360  
361    // Example for Any_Num
362    use cryptocol::random::Any_Num;
363    let mut any_num = Any_Num::new();
364    for i in 0..10
365        { println!("{} Any number (Any_Num) = {}", i, any_num.random_u16()); }
366
367    // Example for Any_Num_C
368    use cryptocol::random::Any_Num_C;
369    let mut any_num_c = Any_Num_C::new();
370    for i in 0..10
371        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_u16()); }
372
373    // Example for Any_MD4
374    use cryptocol::random::Any_MD4;
375    let mut any_md4 = Any_MD4::new();
376    for i in 0..10
377        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_u16()); }
378
379    // Example for Any_MD5
380    use cryptocol::random::Any_MD5;
381    let mut any_md5 = Any_MD5::new();
382    for i in 0..10
383        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_u16()); }
384
385    // Example for Any_SHA0
386    use cryptocol::random::Any_SHA0;
387    let mut any_sha0 = Any_SHA0::new();
388    for i in 0..10
389        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_u16()); }
390
391    // Example for Any_SHA1
392    use cryptocol::random::Any_SHA1;
393    let mut any_sha1 = Any_SHA1::new();
394    for i in 0..10
395        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_u16()); }
396
397    // Example for Any_SHA2_256
398    use cryptocol::random::Any_SHA2_256;
399    let mut any_sha2_256 = Any_SHA2_256::new();
400    for i in 0..10
401        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_u16()); }
402
403    // Example for Any_SHA2_512
404    use cryptocol::random::Any_SHA2_512;
405    let mut any_sha2_512 = Any_SHA2_512::new();
406    for i in 0..10
407        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_u16()); }
408
409    // Example for Random_SHA2_512
410    use cryptocol::random::Random_SHA2_512;
411    let mut rand_sha2_512 = Random_SHA2_512::new();
412    for i in 0..10
413        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_u16()); }
414
415    // Example for Random_Generic
416    use cryptocol::random::Random_Generic;
417    use cryptocol::hash::SHA1_Expanded;
418    type MySHA1 = SHA1_Expanded<5, 0x1111_1111, 0x4444_4444, 0x8888_8888, 0xcccc_cccc, 0xffff_ffff, 160>;
419    let mut any_sha1_expanded = Random_Generic::<500000000>::new_with_generators_seeds(MySHA1::new(), MySHA1::new(), 6445332556087625_u64, 43057945771605458_u64);
420    for i in 0..10
421        { println!("{} Any number (Random_Generic) = {}", i, any_sha1_expanded.random_u16()); }
422    println!("-------------------------------");
423}
424
425fn random_random_u32()
426{
427    println!("random_random_u32");
428    // Example for Random
429    use cryptocol::random::Random;
430    let mut rand = Random::new();
431    for i in 0..10
432        { println!("{} Random number (Random) = {}", i, rand.random_u32()); }
433
434    // Example for Any
435    use cryptocol::random::Any;
436    let mut any = Any::new();
437    for i in 0..10
438        { println!("{} Any number (Any) = {}", i, any.random_u32()); }
439  
440    // Example for Any_Num
441    use cryptocol::random::Any_Num;
442    let mut any_num = Any_Num::new();
443    for i in 0..10
444        { println!("{} Any number (Any_Num) = {}", i, any_num.random_u32()); }
445
446    // Example for Any_Num_C
447    use cryptocol::random::Any_Num_C;
448    let mut any_num_c = Any_Num_C::new();
449    for i in 0..10
450        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_u32()); }
451
452    // Example for Any_MD4
453    use cryptocol::random::Any_MD4;
454    let mut any_md4 = Any_MD4::new();
455    for i in 0..10
456        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_u32()); }
457
458    // Example for Any_MD5
459    use cryptocol::random::Any_MD5;
460    let mut any_md5 = Any_MD5::new();
461    for i in 0..10
462        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_u32()); }
463
464    // Example for Any_SHA0
465    use cryptocol::random::Any_SHA0;
466    let mut any_sha0 = Any_SHA0::new();
467    for i in 0..10
468        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_u32()); }
469
470    // Example for Any_SHA1
471    use cryptocol::random::Any_SHA1;
472    let mut any_sha1 = Any_SHA1::new();
473    for i in 0..10
474        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_u32()); }
475
476    // Example for Any_SHA2_256
477    use cryptocol::random::Any_SHA2_256;
478    let mut any_sha2_256 = Any_SHA2_256::new();
479    for i in 0..10
480        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_u32()); }
481
482    // Example for Any_SHA2_512
483    use cryptocol::random::Any_SHA2_512;
484    let mut any_sha2_512 = Any_SHA2_512::new();
485    for i in 0..10
486        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_u32()); }
487
488    // Example for Random_SHA2_512
489    use cryptocol::random::Random_SHA2_512;
490    let mut rand_sha2_512 = Random_SHA2_512::new();
491    for i in 0..10
492        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_u32()); }
493
494    // Example for Random_Generic
495    use cryptocol::random::Random_Generic;
496    use cryptocol::hash::SHA2_256_Expanded;
497    type MySHA2 = SHA2_256_Expanded<0x1111_1111, 0x2222_2222, 0x4444_4444, 0x6666_6666, 0x8888_8888, 0xaaaa_aaaa, 0xcccc_cccc, 0xeeee_eeee, 128>;
498    let mut any_sha2_expanded = Random_Generic::<102030405060708090>::new_with_generators_seeds(MySHA2::new(), MySHA2::new(), 6445332556087625_u64, 43057945771605458_u64);
499    for i in 0..10
500        { println!("{} Any number (Random_Generic) = {}", i, any_sha2_expanded.random_u32()); }
501    println!("-------------------------------");
502}
503
504fn random_random_u64()
505{
506    println!("random_random_u64");
507    // Example for Random
508    use cryptocol::random::Random;
509    let mut rand = Random::new();
510    for i in 0..10
511        { println!("{} Random number (Random) = {}", i, rand.random_u64()); }
512
513    // Example for Any
514    use cryptocol::random::Any;
515    let mut any = Any::new();
516    for i in 0..10
517        { println!("{} Any number (Any) = {}", i, any.random_u64()); }
518  
519    // Example for Any_Num
520    use cryptocol::random::Any_Num;
521    let mut any_num = Any_Num::new();
522    for i in 0..10
523        { println!("{} Any number (Any_Num) = {}", i, any_num.random_u64()); }
524
525    // Example for Any_Num_C
526    use cryptocol::random::Any_Num_C;
527    let mut any_num_c = Any_Num_C::new();
528    for i in 0..10
529        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_u64()); }
530
531    // Example for Any_MD4
532    use cryptocol::random::Any_MD4;
533    let mut any_md4 = Any_MD4::new();
534    for i in 0..10
535        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_u64()); }
536
537    // Example for Any_MD5
538    use cryptocol::random::Any_MD5;
539    let mut any_md5 = Any_MD5::new();
540    for i in 0..10
541        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_u64()); }
542
543    // Example for Any_SHA0
544    use cryptocol::random::Any_SHA0;
545    let mut any_sha0 = Any_SHA0::new();
546    for i in 0..10
547        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_u64()); }
548
549    // Example for Any_SHA1
550    use cryptocol::random::Any_SHA1;
551    let mut any_sha1 = Any_SHA1::new();
552    for i in 0..10
553        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_u64()); }
554
555    // Example for Any_SHA2_256
556    use cryptocol::random::Any_SHA2_256;
557    let mut any_sha2_256 = Any_SHA2_256::new();
558    for i in 0..10
559        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_u64()); }
560
561    // Example for Any_SHA2_512
562    use cryptocol::random::Any_SHA2_512;
563    let mut any_sha2_512 = Any_SHA2_512::new();
564    for i in 0..10
565        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_u64()); }
566
567    // Example for Random_SHA2_512
568    use cryptocol::random::Random_SHA2_512;
569    let mut rand_sha2_512 = Random_SHA2_512::new();
570    for i in 0..10
571        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_u64()); }
572
573    // Example for Random_Generic
574    use cryptocol::random::Random_Generic;
575    use cryptocol::hash::SHA2_512_Expanded;
576    type MySHA2 = SHA2_512_Expanded<0x1111_1111_1111_1111, 0x3333_3333_3333_3333, 0x5555_5555_5555_5555, 0x7777_7777_7777_7777, 0x9999_9999_9999_9999, 0xbbbb_bbbb_bbbb_bbbb, 0xdddd_dddd_dddd_dddd, 0xffff_ffff_ffff_ffff, 160>;
577    let mut any_sha2_expanded = Random_Generic::<100000>::new_with_generators_seeds(MySHA2::new(), MySHA2::new(), 6445332556087625_u64, 43057945771605458_u64);
578    for i in 0..10
579        { println!("{} Any number (Random_Generic) = {}", i, any_sha2_expanded.random_u64()); }
580    println!("-------------------------------");
581}
582
583fn random_random_u128()
584{
585    println!("random_random_u128");
586    // Example for Random
587    use cryptocol::random::Random;
588    let mut rand = Random::new();
589    for i in 0..10
590        { println!("{} Random number (Random) = {}", i, rand.random_u128()); }
591
592    // Example for Any
593    use cryptocol::random::Any;
594    let mut any = Any::new();
595    for i in 0..10
596        { println!("{} Any number (Any) = {}", i, any.random_u128()); }
597  
598    // Example for Any_Num
599    use cryptocol::random::Any_Num;
600    let mut any_num = Any_Num::new();
601    for i in 0..10
602        { println!("{} Any number (Any_Num) = {}", i, any_num.random_u128()); }
603
604    // Example for Any_Num_C
605    use cryptocol::random::Any_Num_C;
606    let mut any_num_c = Any_Num_C::new();
607    for i in 0..10
608        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_u128()); }
609
610    // Example for Any_MD4
611    use cryptocol::random::Any_MD4;
612    let mut any_md4 = Any_MD4::new();
613    for i in 0..10
614        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_u128()); }
615
616    // Example for Any_MD5
617    use cryptocol::random::Any_MD5;
618    let mut any_md5 = Any_MD5::new();
619    for i in 0..10
620        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_u128()); }
621
622    // Example for Any_SHA0
623    use cryptocol::random::Any_SHA0;
624    let mut any_sha0 = Any_SHA0::new();
625    for i in 0..10
626        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_u128()); }
627
628    // Example for Any_SHA1
629    use cryptocol::random::Any_SHA1;
630    let mut any_sha1 = Any_SHA1::new();
631    for i in 0..10
632        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_u128()); }
633
634    // Example for Any_SHA2_256
635    use cryptocol::random::Any_SHA2_256;
636    let mut any_sha2_256 = Any_SHA2_256::new();
637    for i in 0..10
638        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_u128()); }
639
640    // Example for Any_SHA2_512
641    use cryptocol::random::Any_SHA2_512;
642    let mut any_sha2_512 = Any_SHA2_512::new();
643    for i in 0..10
644        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_u128()); }
645
646    // Example for Random_SHA2_512
647    use cryptocol::random::Random_SHA2_512;
648    let mut rand_sha2_512 = Random_SHA2_512::new();
649    for i in 0..10
650        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_u128()); }
651
652    // Example for Random_Generic
653    use cryptocol::random::{ Random_Generic, AnyNumber_Engine_C_Generic };
654    type MyAnyNumberEngineCExpanded = AnyNumber_Engine_C_Generic<1234567890987654321_u64, 987654321_u64>;
655    let mut any_num_c_expanded = Random_Generic::<258963147>::new_with(MyAnyNumberEngineCExpanded::new(), MyAnyNumberEngineCExpanded::new());
656    for i in 0..10
657        { println!("{} Any number (Random_Generic) = {}", i, any_num_c_expanded.random_u128()); }
658    println!("-------------------------------");
659}
660
661fn random_random_usize()
662{
663    println!("random_random_usize");
664    // Example for Random
665    use cryptocol::random::Random;
666    let mut rand = Random::new();
667    for i in 0..10
668        { println!("{} Random number (Random) = {}", i, rand.random_usize()); }
669
670    // Example for Any
671    use cryptocol::random::Any;
672    let mut any = Any::new();
673    for i in 0..10
674        { println!("{} Any number (Any) = {}", i, any.random_usize()); }
675  
676    // Example for Any_Num
677    use cryptocol::random::Any_Num;
678    let mut any_num = Any_Num::new();
679    for i in 0..10
680        { println!("{} Any number (Any_Num) = {}", i, any_num.random_usize()); }
681
682    // Example for Any_Num_C
683    use cryptocol::random::Any_Num_C;
684    let mut any_num_c = Any_Num_C::new();
685    for i in 0..10
686        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_usize()); }
687
688    // Example for Any_MD4
689    use cryptocol::random::Any_MD4;
690    let mut any_md4 = Any_MD4::new();
691    for i in 0..10
692        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_usize()); }
693
694    // Example for Any_MD5
695    use cryptocol::random::Any_MD5;
696    let mut any_md5 = Any_MD5::new();
697    for i in 0..10
698        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_usize()); }
699
700    // Example for Any_SHA0
701    use cryptocol::random::Any_SHA0;
702    let mut any_sha0 = Any_SHA0::new();
703    for i in 0..10
704        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_usize()); }
705
706    // Example for Any_SHA1
707    use cryptocol::random::Any_SHA1;
708    let mut any_sha1 = Any_SHA1::new();
709    for i in 0..10
710        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_usize()); }
711
712    // Example for Any_SHA2_256
713    use cryptocol::random::Any_SHA2_256;
714    let mut any_sha2_256 = Any_SHA2_256::new();
715    for i in 0..10
716        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_usize()); }
717
718    // Example for Any_SHA2_512
719    use cryptocol::random::Any_SHA2_512;
720    let mut any_sha2_512 = Any_SHA2_512::new();
721    for i in 0..10
722        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_usize()); }
723
724    // Example for Random_SHA2_512
725    use cryptocol::random::Random_SHA2_512;
726    let mut rand_sha2_512 = Random_SHA2_512::new();
727    for i in 0..10
728        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_usize()); }
729
730    // Example for Random_Generic
731    use cryptocol::random::Random_Generic;
732    use cryptocol::hash::SHA2_512_Expanded;
733    type MySHA2 = SHA2_512_Expanded<0x1212_1212_1212_1212, 0x3434_3434_3434_3434, 0x5454_5454_5454_5454, 0x7878_7878_7878_7878, 0x9A9A_9A9A_9A9A_9A9A, 0xbcbc_bcbc_bcbc_bcbc, 0xdede_dede_dede_dede, 0xf0f0_f0f0_f0f0_f0f0, 240>;
734    let mut any_sha2_expanded1 = Random_Generic::<75315964852>::new_with(MySHA2::new(), MySHA2::new());
735    for i in 0..10
736        { println!("{} Any number (Random_Generic) = {}", i, any_sha2_expanded1.random_usize()); }
737    println!("-------------------------------");
738}
739
740fn random_random_uint()
741{
742    println!("random_random_uint");
743    // Example for Random
744    use cryptocol::random::Random;
745    let mut rand = Random::new();
746    for i in 0..10
747        { println!("{} Random number (Random) = {}", i, rand.random_uint::<u8>()); }
748
749    // Example for Any
750    use cryptocol::random::Any;
751    let mut any = Any::new();
752    for i in 0..10
753        { println!("{} Any number (Any) = {}", i, any.random_uint::<u16>()); }
754  
755    // Example for Any_Num
756    use cryptocol::random::Any_Num;
757    let mut any_num = Any_Num::new();
758    for i in 0..10
759        { println!("{} Any number (Any_Num) = {}", i, any_num.random_uint::<u32>()); }
760
761    // Example for Any_Num_C
762    use cryptocol::random::Any_Num_C;
763    let mut any_num_c = Any_Num_C::new();
764    for i in 0..10
765        { println!("{} Any number (Any_Num_C) = {}", i, any_num_c.random_uint::<u64>()); }
766
767    // Example for Any_MD4
768    use cryptocol::random::Any_MD4;
769    let mut any_md4 = Any_MD4::new();
770    for i in 0..10
771        { println!("{} Any number (Any_MD4) = {}", i, any_md4.random_uint::<u128>()); }
772
773    // Example for Any_MD5
774    use cryptocol::random::Any_MD5;
775    let mut any_md5 = Any_MD5::new();
776    for i in 0..10
777        { println!("{} Any number (Any_MD5) = {}", i, any_md5.random_uint::<usize>()); }
778
779    // Example for Any_SHA0
780    use cryptocol::random::Any_SHA0;
781    let mut any_sha0 = Any_SHA0::new();
782    for i in 0..10
783        { println!("{} Any number (Any_SHA0) = {}", i, any_sha0.random_uint::<u8>()); }
784
785    // Example for Any_SHA1
786    use cryptocol::random::Any_SHA1;
787    let mut any_sha1 = Any_SHA1::new();
788    for i in 0..10
789        { println!("{} Any number (Any_SHA1) = {}", i, any_sha1.random_uint::<u16>()); }
790
791    // Example for Any_SHA2_256
792    use cryptocol::random::Any_SHA2_256;
793    let mut any_sha2_256 = Any_SHA2_256::new();
794    for i in 0..10
795        { println!("{} Any number (Any_SHA2_256) = {}", i, any_sha2_256.random_uint::<u32>()); }
796
797    // Example for Any_SHA2_512
798    use cryptocol::random::Any_SHA2_512;
799    let mut any_sha2_512 = Any_SHA2_512::new();
800    for i in 0..10
801        { println!("{} Any number (Any_SHA2_512) = {}", i, any_sha2_512.random_uint::<u64>()); }
802
803    // Example for Random_SHA2_512
804    use cryptocol::random::Random_SHA2_512;
805    let mut rand_sha2_512 = Random_SHA2_512::new();
806    for i in 0..10
807        { println!("{} Random number (Random_SHA2_512) = {}", i, rand_sha2_512.random_uint::<u128>()); }
808
809    // Example for Random_Generic
810    use cryptocol::random::Random_Generic;
811    use cryptocol::hash::SHA2_512_Expanded;
812    type MySHA2 = SHA2_512_Expanded<0x1212_1212_1212_1212, 0x3434_3434_3434_3434, 0x5454_5454_5454_5454, 0x7878_7878_7878_7878, 0x9A9A_9A9A_9A9A_9A9A, 0xbcbc_bcbc_bcbc_bcbc, 0xdede_dede_dede_dede, 0xf0f0_f0f0_f0f0_f0f0, 240>;
813    let mut any_sha2_expanded2 = Random_Generic::<555555555>::new_with(MySHA2::new(), MySHA2::new());
814    for i in 0..10
815        { println!("{} Any number (Random_Generic) = {}", i, any_sha2_expanded2.random_uint::<u128>()); }
816    println!("-------------------------------");
817}
818
819fn random_random_under_uint()
820{
821    println!("random_random_under_uint");
822    use cryptocol::random::Random_SHA2_512;
823    let mut rand = Random_SHA2_512::new();
824    if let Some(num) = rand.random_under_uint(12_u8)
825        { println!("Random number u8 = {}", num); }
826    if let Some(num) = rand.random_under_uint(1234_u16)
827        { println!("Random number u16 = {}", num); }
828    if let Some(num) = rand.random_under_uint(12345678_u32)
829        { println!("Random number u32 = {}", num); }
830    if let Some(num) = rand.random_under_uint(1234567890123456_u64)
831        { println!("Random number u64 = {}", num); }
832    if let Some(num) = rand.random_under_uint(12345678901234567890_u128)
833        { println!("Random number u128 = {}", num); }
834    if let Some(num) = rand.random_under_uint(123456789_usize)
835        { println!("Random number usize = {}", num); }
836    if let Some(num) = rand.random_under_uint(0_usize)
837        { println!("Random number usize = {}", num); }
838    else
839        { println!("No random unsigned number number under 0!"); }
840    println!("-------------------------------");
841}
842
843fn random_random_under_uint_()
844{
845    println!("random_random_under_uint_");
846    use cryptocol::random::Any_Num;
847    let mut rand = Any_Num::new();
848
849    let num = rand.random_under_uint_(12_u8);
850    println!("Random number u8 = {}", num);
851
852    let num = rand.random_under_uint_(1234_u16);
853    println!("Random number u16 = {}", num);
854
855    let num = rand.random_under_uint_(12345678_u32);
856    println!("Random number u32 = {}", num);
857
858    let num = rand.random_under_uint_(1234567890123456_u64);
859    println!("Random number u64 = {}", num);
860
861    let num = rand.random_under_uint_(12345678901234567890_u128);
862    println!("Random number u128 = {}", num);
863
864    let num = rand.random_under_uint_::<usize>(123456789_usize);
865    println!("Random number usize = {}", num);
866
867    // It will panic.
868    // let num = rand.random_under_uint_::<usize>(0_usize);
869    // println!("Random number usize = {}", num);
870    println!("-------------------------------");
871}
872
873fn random_random_minmax_uint()
874{
875    println!("random_random_minmax_uint");
876    use cryptocol::random::Any_MD4;
877    let mut rand = Any_MD4::new();
878    if let Some(num) = rand.random_minmax_uint(12_u8, 21)
879        { println!("Random number u8 = {}", num); }
880    if let Some(num) = rand.random_minmax_uint(1234_u16, 6321)
881        { println!("Random number u16 = {}", num); }
882    if let Some(num) = rand.random_minmax_uint(12345678_u32, 87654321)
883        { println!("Random number u32 = {}", num); }
884    if let Some(num) = rand.random_minmax_uint(1234567890123456_u64, 6543210987654321)
885        { println!("Random number u64 = {}", num); }
886    if let Some(num) = rand.random_minmax_uint(12345678901234567890_u128, 19876543210987654321)
887        { println!("Random number u128 = {}", num); }
888    if let Some(num) = rand.random_minmax_uint(123456789_usize, 987654321)
889        { println!("Random number usize = {}", num); }
890    if let Some(num) = rand.random_minmax_uint(10, 8_usize)
891        { println!("Random number usize = {}", num); }
892    else
893        { println!("No random unsigned number number greater than or equal to 10 and less than 8!"); }
894    println!("-------------------------------");
895}
896
897fn random_random_minmax_uint_()
898{
899    println!("random_random_minmax_uint_");
900    use cryptocol::random::Any_MD5;
901    let mut rand = Any_MD5::new();
902
903    let num = rand.random_minmax_uint_(12_u8, 21);
904    println!("Random number u8 = {}", num);
905
906    let num = rand.random_minmax_uint_(1234_u16, 6321);
907    println!("Random number u16 = {}", num);
908
909    let num = rand.random_minmax_uint_(12345678_u32, 87654321);
910    println!("Random number u32 = {}", num);
911
912    let num = rand.random_minmax_uint_(1234567890123456_u64, 6543210987654321);
913    println!("Random number u64 = {}", num);
914
915    let num = rand.random_minmax_uint_(12345678901234567890_u128, 19876543210987654321);
916    println!("Random number u128 = {}", num);
917
918    let num = rand.random_minmax_uint_(123456789_usize, 987654321);
919    println!("Random number usize = {}", num);
920
921    // It will panic!
922    // let num = rand.random_minmax_uint_(10, 8_usize);
923    // println!("Random number usize = {}", num);
924    println!("-------------------------------");
925}
926
927fn random_random_odd_uint()
928{
929    println!("random_random_odd_uint");
930    use cryptocol::random::Any_SHA0;
931    let mut rand = Any_SHA0::new();
932    println!("Random odd number u8 = {}", rand.random_odd_uint::<u8>());
933    println!("Random odd number u16 = {}", rand.random_odd_uint::<u16>());
934    println!("Random odd number u32 = {}", rand.random_odd_uint::<u32>());
935    println!("Random odd number u64 = {}", rand.random_odd_uint::<u64>());
936    println!("Random odd number u128 = {}", rand.random_odd_uint::<u128>());
937    println!("Random odd number usize = {}", rand.random_odd_uint::<usize>());
938    println!("-------------------------------");
939}
940
941fn random_random_odd_under_uint()
942{
943    println!("random_random_odd_under_uint");
944    use cryptocol::random::Any_SHA1;
945    let mut rand = Any_SHA1::new();
946    if let Some(num) = rand.random_odd_under_uint(12_u8)
947        { println!("Random odd number u8 = {}", num); }
948    if let Some(num) = rand.random_odd_under_uint(1234_u16)
949        { println!("Random odd number u16 = {}", num); }
950    if let Some(num) = rand.random_odd_under_uint(12345678_u32)
951        { println!("Random odd number u32 = {}", num); }
952    if let Some(num) = rand.random_odd_under_uint(1234567890123456_u64)
953        { println!("Random odd number u64 = {}", num); }
954    if let Some(num) = rand.random_odd_under_uint(12345678901234567890_u128)
955        { println!("Random odd number u128 = {}", num); }
956    if let Some(num) = rand.random_odd_under_uint(123456789_usize)
957        { println!("Random odd number usize = {}", num); }
958    if let Some(num) = rand.random_odd_under_uint(0_usize)
959        { println!("Random odd number usize = {}", num); }
960    else
961        { println!("No random unsigned number number under 0!"); }
962    println!("-------------------------------");
963}
964
965fn random_random_odd_under_uint_()
966{
967    println!("random_random_odd_under_uint_");
968    use cryptocol::random::Any_SHA2_256;
969    let mut rand = Any_SHA2_256::new();
970
971    let num = rand.random_odd_under_uint_(12_u8);
972    println!("Random odd number u8 = {}", num);
973
974    let num = rand.random_odd_under_uint_(1234_u16);
975    println!("Random odd number u16 = {}", num);
976
977    let num = rand.random_odd_under_uint_(12345678_u32);
978    println!("Random odd number u32 = {}", num);
979
980    let num = rand.random_odd_under_uint_(1234567890123456_u64);
981    println!("Random odd number u64 = {}", num);
982
983    let num = rand.random_odd_under_uint_(12345678901234567890_u128);
984    println!("Random odd number u128 = {}", num);
985
986    let num = rand.random_odd_under_uint_::<usize>(123456789_usize);
987    println!("Random odd number usize = {}", num);
988
989    // It will panic.
990    // let num = rand.random_odd_under_uint_::<usize>(0_usize);
991    // println!("Random odd number usize = {}", num);
992    println!("-------------------------------");
993}
994
995fn random_random_with_msb_set_uint()
996{
997    println!("random_random_with_msb_set_uint");
998    use cryptocol::random::Random_SHA2_512;
999    let mut rand = Random_SHA2_512::new();
1000    println!("Random 8-bit number u8 = {}", rand.random_with_msb_set_uint::<u8>());
1001    println!("Random 16-bit number u16 = {}", rand.random_with_msb_set_uint::<u16>());
1002    println!("Random 32-bit number u32 = {}", rand.random_with_msb_set_uint::<u32>());
1003    println!("Random 64-bit number u64 = {}", rand.random_with_msb_set_uint::<u64>());
1004    println!("Random 128-bit number u128 = {}", rand.random_with_msb_set_uint::<u128>());
1005    println!("Random usize-sized number usize = {}", rand.random_with_msb_set_uint::<usize>());
1006    println!("-------------------------------");
1007}
1008
1009fn random_random_odd_with_msb_set_uint()
1010{
1011    println!("random_random_odd_with_msb_set_uint");
1012    use cryptocol::random::Random;
1013    let mut rand = Random::new();
1014    println!("Random 8-bit odd number u8 = {}", rand.random_with_msb_set_uint::<u8>());
1015    println!("Random 16-bit odd number u16 = {}", rand.random_with_msb_set_uint::<u16>());
1016    println!("Random 32-bit odd number u32 = {}", rand.random_with_msb_set_uint::<u32>());
1017    println!("Random 64-bit odd number u64 = {}", rand.random_with_msb_set_uint::<u64>());
1018    println!("Random 128-bit odd number u128 = {}", rand.random_with_msb_set_uint::<u128>());
1019    println!("Random usize-sized odd number usize = {}", rand.random_with_msb_set_uint::<usize>());
1020    println!("-------------------------------");
1021}
1022
1023fn random_random_prime_using_miller_rabin_uint()
1024{
1025    println!("random_random_prime_using_miller_rabin_uint");
1026    use cryptocol::random::Any;
1027    let mut rand = Any::new();
1028    println!("Random prime number u8 = {}", rand.random_prime_using_miller_rabin_uint::<u8>(5));
1029    println!("Random prime number u16 = {}", rand.random_prime_using_miller_rabin_uint::<u16>(5));
1030    println!("Random prime number u32 = {}", rand.random_prime_using_miller_rabin_uint::<u32>(5));
1031    println!("Random prime number u64 = {}", rand.random_prime_using_miller_rabin_uint::<u64>(5));
1032    println!("Random prime number u128 = {}", rand.random_prime_using_miller_rabin_uint::<u128>(5));
1033    println!("Random prime number usize = {}", rand.random_prime_using_miller_rabin_uint::<usize>(5));
1034    println!("-------------------------------");
1035}
1036
1037fn random_random_prime_with_msb_set_using_miller_rabin_uint()
1038{
1039    println!("random_random_prime_with_msb_set_using_miller_rabin_uint");
1040    use cryptocol::random::Random;
1041    let mut rand = Random::new();
1042    println!("Random 8-bit prime number u8 = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<u8>(5));
1043    println!("Random 16-bit prime number u16 = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<u16>(5));
1044    println!("Random 32-bit prime number u32 = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<u32>(5));
1045    println!("Random 64-bit prime number u64 = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<u64>(5));
1046    println!("Random 128-bit prime number u128 = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<u128>(5));
1047    println!("Random usize-sized prime number usize = {}", rand.random_prime_with_msb_set_using_miller_rabin_uint::<usize>(5));
1048    println!("-------------------------------");
1049}
1050
1051fn random_random_array()
1052{
1053    println!("random_random_array");
1054    use cryptocol::random::Any;
1055    let mut rand = Any::new();
1056    let num: [u128; 20] = rand.random_array();
1057    for i in 0..20
1058        { println!("Random number {} => {}", i, num[i]); }
1059    println!("-------------------------------");
1060}
1061
1062fn random_put_random_array()
1063{
1064    println!("random_random_array");
1065    use cryptocol::random::Any_MD4;
1066    let mut rand = Any_MD4::new();
1067    let mut num = [0_u64; 32];
1068    rand.put_random_in_array(&mut num);
1069    for i in 0..32
1070        { println!("Random number {} => {}", i, num[i]); }
1071    println!("-------------------------------");
1072}
1073
1074fn random_random_biguint()
1075{
1076    println!("random_random_biguint");
1077    use cryptocol::define_utypes_with;
1078    use cryptocol::random::Any_MD5;
1079
1080    define_utypes_with!(u128);
1081    let mut rand = Any_MD5::new();
1082    let biguint: U512 = rand.random_biguint();
1083    println!("Random Number: {}", biguint);
1084    println!("-------------------------------");
1085}
1086
1087fn random_random_under_biguint()
1088{
1089    println!("random_random_under_biguint");
1090    use cryptocol::define_utypes_with;
1091    use cryptocol::random::Any_SHA0;
1092
1093    define_utypes_with!(u64);
1094    let mut rand = Any_SHA0::new();
1095    let ceiling = U1024::max().wrapping_div_uint(3_u8);
1096    if let Some(r) = rand.random_under_biguint(&ceiling)
1097    {
1098        println!("Random Number less than {} is\n{}", ceiling, r);
1099        assert!(r < ceiling);
1100    }
1101    println!("-------------------------------");
1102}
1103
1104fn random_random_under_biguint_()
1105{
1106    println!("random_random_under_biguint_");
1107    use cryptocol::define_utypes_with;
1108    use cryptocol::random::Any_SHA1;
1109
1110    define_utypes_with!(u32);
1111    let mut rand = Any_SHA1::new();
1112    let ceiling = U1024::max().wrapping_div_uint(3_u8);
1113    let r = rand.random_under_biguint_(&ceiling);
1114    println!("Random Number less than {} is\n{}", ceiling, r);
1115    assert!(r < ceiling);
1116    println!("-------------------------------");
1117}
1118
1119fn random_random_odd_biguint()
1120{
1121    println!("random_random_odd_biguint");
1122    use cryptocol::define_utypes_with;
1123    use cryptocol::random::Any_SHA2_256;
1124
1125    define_utypes_with!(u16);
1126    let mut rand = Any_SHA2_256::new();
1127    let ceiling = U1024::max().wrapping_div_uint(3_u8);
1128    let r = rand.random_under_biguint_(&ceiling);
1129    println!("Random Number less than {} is\n{}", ceiling, r);
1130    assert!(r < ceiling);
1131    println!("-------------------------------");
1132}
1133
1134fn random_random_odd_under_biguint()
1135{
1136    println!("random_random_odd_under_biguint");
1137    use cryptocol::define_utypes_with;
1138    use cryptocol::random::Any_MD4;
1139
1140    define_utypes_with!(u128);
1141    let mut rand = Any_MD4::new();
1142    let ceiling = U1024::max().wrapping_div_uint(4_u8);
1143    if let Some(r) = rand.random_odd_under_biguint(&ceiling)
1144    {
1145        println!("Random odd Number less than {} is\n{}", ceiling, r);
1146        assert!(r < ceiling);
1147    }
1148    println!("-------------------------------");
1149}
1150
1151fn random_random_odd_under_biguint_()
1152{
1153    println!("random_random_odd_under_biguint_");
1154    use cryptocol::define_utypes_with;
1155    use cryptocol::random::Any_SHA2_512;
1156
1157    define_utypes_with!(u8);
1158    let mut rand = Any_SHA2_512::new();
1159    let ceiling = U1024::max().wrapping_div_uint(3_u8);
1160    let r = rand.random_odd_under_biguint_(&ceiling);
1161    println!("Random odd Number less than {} is\n{}", ceiling, r);
1162    assert!(r < ceiling);
1163    println!("-------------------------------");
1164}
1165
1166fn random_random_with_msb_set_biguint()
1167{
1168    println!("random_random_with_msb_set_biguint");
1169    use cryptocol::define_utypes_with;
1170    use cryptocol::random::Any_MD5;
1171
1172    define_utypes_with!(u64);
1173    let mut rand = Any_MD5::new();
1174    let biguint: U512 = rand.random_with_msb_set_biguint();
1175    println!("Random Number: {}", biguint);
1176    println!("-------------------------------");
1177}
1178
1179fn random_random_odd_with_msb_set_biguint()
1180{
1181    println!("random_random_odd_with_msb_set_biguint");
1182    use cryptocol::define_utypes_with;
1183    use cryptocol::random::Any;
1184
1185    define_utypes_with!(u32);
1186    let mut rand = Any::new();
1187    let num:U512 = rand.random_odd_with_msb_set_biguint();
1188    println!("512-bit Random Odd Number = {}", num);
1189    assert!(num > U512::halfmax());
1190    assert!(num.is_odd());
1191    println!("-------------------------------");
1192}
1193
1194fn random_random_prime_using_miller_rabin_biguint()
1195{
1196    println!("random_random_prime_using_miller_rabin_biguint");
1197    use cryptocol::define_utypes_with;
1198    use cryptocol::random::Random;
1199
1200    define_utypes_with!(u16);
1201    let mut rand = Random::new();
1202    let num:U512 = rand.random_prime_using_miller_rabin_biguint(5);
1203    println!("Random Prime Number = {}", num);
1204    assert!(num.is_odd());
1205    println!("-------------------------------");
1206}
1207
1208fn random_random_prime_with_msb_set_using_miller_rabin_biguint()
1209{
1210    println!("random_random_prime_with_msb_set_using_miller_rabin_biguint");
1211    use cryptocol::define_utypes_with;
1212    use cryptocol::random::Any_SHA1;
1213
1214    define_utypes_with!(u16);
1215    let mut rand = Any_SHA1::new();
1216    let num:U512 = rand.random_prime_with_msb_set_using_miller_rabin_biguint(5);
1217    println!("512-bit Random Prime Number = {}", num);
1218    assert!(num.is_odd());
1219    println!("-------------------------------");
1220}
1221
1222
1223/*
1224use std::ops::*;
1225use std::fmt::{ Display, Debug };
1226use rand::{ rngs, RngCore };
1227
1228use cryptocol::number::SmallUInt;
1229use cryptocol::random::{ random_Engine, random_Generic };
1230
1231pub struct OsRng;
1232{
1233    hash_code: [u64; 8]
1234}
1235
1236impl random_Engine for OsRng
1237{
1238    #[inline]
1239    fn new() -> Self
1240    {
1241        Self { hash_code: [0_u64; 8] }
1242    }
1243
1244    #[inline]
1245    fn new_with<T, const N: usize>(_: &[T; N]) -> Self
1246    where T: SmallUInt + Copy + Clone + Display + Debug + ToString
1247        + Add<Output=T> + AddAssign + Sub<Output=T> + SubAssign
1248        + Mul<Output=T> + MulAssign + Div<Output=T> + DivAssign
1249        + Rem<Output=T> + RemAssign
1250        + Shl<Output=T> + ShlAssign + Shr<Output=T> + ShrAssign
1251        + BitAnd<Output=T> + BitAndAssign + BitOr<Output=T> + BitOrAssign
1252        + BitXor<Output=T> + BitXorAssign + Not<Output=T>
1253        + PartialEq + PartialOrd
1254    {
1255        Self::new()
1256    }
1257
1258    #[inline]
1259    fn sow_array<T, const N: usize>(&mut self, _: &[T; N])
1260    where T: SmallUInt + Copy + Clone + Display + Debug + ToString
1261        + Add<Output=T> + AddAssign + Sub<Output=T> + SubAssign
1262        + Mul<Output=T> + MulAssign + Div<Output=T> + DivAssign
1263        + Rem<Output=T> + RemAssign
1264        + Shl<Output=T> + ShlAssign + Shr<Output=T> + ShrAssign
1265        + BitAnd<Output=T> + BitAndAssign + BitOr<Output=T> + BitOrAssign
1266        + BitXor<Output=T> + BitXorAssign + Not<Output=T>
1267        + PartialEq + PartialOrd
1268    {}
1269
1270    #[inline]
1271    fn harvest(&mut self, _: u64) -> [u64; 8]
1272    {
1273        [rngs::OsRng.next_u64(), rngs::OsRng.next_u64(),
1274        rngs::OsRng.next_u64(), rngs::OsRng.next_u64(),
1275        rngs::OsRng.next_u64(), rngs::OsRng.next_u64(),
1276        rngs::OsRng.next_u64(), rngs::OsRng.next_u64()]
1277    }
1278}
1279
1280fn Hash_OS_Rng_main()
1281{
1282    pub type random_OsRng = random_Generic<OsRng>;
1283    
1284    let mut r = random_OsRng::new();
1285    println!("random_OsRng u8 = {}", r.random_u8());
1286    println!("random_OsRng u16 = {}", r.random_u16());
1287    println!("random_OsRng u32 = {}", r.random_u32());
1288    println!("random_OsRng u64 = {}", r.random_u64());
1289    println!("random_OsRng u128 = {}", r.random_u128());
1290    println!("random_OsRng under 123456789 = {}", r.random_under_uint_(123456789_u64));
1291    println!("random_OsRng prime number = {}", r.random_prime_using_miller_rabin_uint::<u128>(5));
1292    println!("random_OsRng under BigUInt = {}", r.random_biguint::<u64, 8>());
1293    println!("random_OsRng odd BigUInt = {}", r.random_odd_biguint::<u64, 8>());
1294    println!("random_OsRng BigUInt prime number = {}", r.random_prime_using_miller_rabin_biguint::<u64, 8>(5));
1295}
1296*/
random_examples/random_examples.rs

random_examples/
random_examples.rs
