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

random_examples/
random_examples.rs
