polenta 0.1.2

A toy language about polynomials over finite-fields
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use lambdaworks_math::field::fields::fft_friendly::{
    babybear::Babybear31PrimeField, stark_252_prime_field::Stark252PrimeField,
    u64_goldilocks::U64GoldilocksPrimeField,
    u64_mersenne_montgomery_field::Mersenne31MontgomeryPrimeField,
};

use crate::{
    fields::{export_symbols, import_symbols, FieldType},
    interpreter::Polenta,
    utils::PolentaUtilExt,
    PolentaError,
};

/// A type-erased Polenta interpreter that can switch between concrete field types at runtime.
pub enum PolentaInstance {
    Babybear31(Polenta<Babybear31PrimeField>),
    Goldilocks(Polenta<U64GoldilocksPrimeField>),
    Stark252(Polenta<Stark252PrimeField>),
    Mersenne31(Polenta<Mersenne31MontgomeryPrimeField>),
}

impl PolentaInstance {
    pub fn new(field_type: FieldType) -> Self {
        match field_type {
            FieldType::Babybear31 => PolentaInstance::Babybear31(Polenta::new()),
            FieldType::Goldilocks => PolentaInstance::Goldilocks(Polenta::new()),
            FieldType::Stark252 => PolentaInstance::Stark252(Polenta::new()),
            FieldType::Mersenne31 => PolentaInstance::Mersenne31(Polenta::new()),
        }
    }

    pub fn field_type(&self) -> FieldType {
        match self {
            PolentaInstance::Babybear31(_) => FieldType::Babybear31,
            PolentaInstance::Goldilocks(_) => FieldType::Goldilocks,
            PolentaInstance::Stark252(_) => FieldType::Stark252,
            PolentaInstance::Mersenne31(_) => FieldType::Mersenne31,
        }
    }

    pub fn interpret(&mut self, input: &str) -> Result<String, PolentaError> {
        match self {
            PolentaInstance::Babybear31(p) => {
                let polys = p.interpret(input)?;
                Ok(Polenta::<Babybear31PrimeField>::poly_print(
                    polys.last().unwrap(),
                ))
            }
            PolentaInstance::Goldilocks(p) => {
                let polys = p.interpret(input)?;
                Ok(Polenta::<U64GoldilocksPrimeField>::poly_print(
                    polys.last().unwrap(),
                ))
            }
            PolentaInstance::Stark252(p) => {
                let polys = p.interpret(input)?;
                Ok(Polenta::<Stark252PrimeField>::poly_print(
                    polys.last().unwrap(),
                ))
            }
            PolentaInstance::Mersenne31(p) => {
                let polys = p.interpret(input)?;
                Ok(Polenta::<Mersenne31MontgomeryPrimeField>::poly_print(
                    polys.last().unwrap(),
                ))
            }
        }
    }

    /// Migrate symbols from another instance by converting coefficients via hex.
    /// `from_hex` on the target field auto-reduces mod p, so this works for any field pair.
    pub fn migrate_symbols_from(&mut self, other: &PolentaInstance) {
        let exported = match other {
            PolentaInstance::Babybear31(p) => export_symbols(&p.symbols),
            PolentaInstance::Goldilocks(p) => export_symbols(&p.symbols),
            PolentaInstance::Stark252(p) => export_symbols(&p.symbols),
            PolentaInstance::Mersenne31(p) => export_symbols(&p.symbols),
        };
        match self {
            PolentaInstance::Babybear31(p) => import_symbols(&mut p.symbols, &exported),
            PolentaInstance::Goldilocks(p) => import_symbols(&mut p.symbols, &exported),
            PolentaInstance::Stark252(p) => import_symbols(&mut p.symbols, &exported),
            PolentaInstance::Mersenne31(p) => import_symbols(&mut p.symbols, &exported),
        }
    }
}