summaryrefslogtreecommitdiff
path: root/lab7/src/main.rs
blob: 271116a069eed6d963ff68ecaf2af0b8c2bb343b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
use rug::{rand::RandState, Complete, Integer};
use std::io;

fn rabin_miller_test(n: &Integer, k: u32) -> bool {
    let one = Integer::from(1u32);
    let two = Integer::from(2u32);
    let n1 = Integer::from(n - 1u32);

    let mut s = 0;
    let mut d = n1.clone();
    while d.mod_u(2u32) == 0 {
        s += 1u32;
        d /= 2u32;
    }

    let mut rand = RandState::new();

    'outer: for _ in 0..k {
        let bound = n.clone() - 4u32;
        let a = bound.random_below(&mut rand) + 2u32;
        let mut x = Integer::from(a.pow_mod_ref(&d, n).unwrap());
        if x == one || x == n1 {
            continue;
        } else {
            for _ in 0..=s - 1 {
                x = Integer::from(x.pow_mod_ref(&two, n).unwrap());
                if x == one {
                    return false;
                } else if x == n1 {
                    continue 'outer;
                }
            }
        }
        return false;
    }
    return true;
}

fn main() {
    println!("Введите положительное нечётное число n:");
    let mut p = String::new();
    let stdin = io::stdin();
    match stdin.read_line(&mut p) {
        Ok(_) => (),
        Err(_) => {
            println!("Произошла ошибка при чтении из стандартного ввода");
            return ();
        }
    }
    let p = match Integer::parse(p) {
        Ok(parsed) => parsed.complete(),
        Err(_) => {
            println!("Не удалось считать число");
            return ();
        }
    };
    if p.is_divisible(&Integer::from(2u32)) {
        println!("Введено чётное число");
        return ();
    }

    println!("Введите количество раундов k:");
    let mut k = String::new();
    match stdin.read_line(&mut k) {
        Ok(_) => (),
        Err(_) => {
            println!("Произошла ошибка при чтении из стандартного ввода");
            return ();
        }
    }
    let k = match k.trim_end().parse::<u32>() {
        Ok(parsed) => parsed,
        Err(_) => {
            println!("Не удалось считать число");
            return ();
        }
    };

    let is_prime = rabin_miller_test(&p, k);
    if is_prime {
        let probability = 1f64 - 0.25f64.powf(k as f64);
        println!(
            "Число {} является простым с вероятностью {}",
            &p, probability
        );
    } else {
        println!("Число не является простым");
    }
}