Struct G1

#[repr(C)]
pub struct G1 {
    pub x: Fp,
    pub y: Fp,
    pub z: Fp,
}

Fields

x: Fp

y: Fp

z: Fp

Implementations

impl G1

pub fn zero() -> G1

pub unsafe fn uninit() -> G1

Examples found in repository

examples/main.rs (line 51)

fn main() {
    println!("mcl version={:04x}", get_version());
    let b = init(CurveType::BN254);
    if !b {
        println!("init err");
    }
    let mut x = Fr::zero();
    println!("x={}", x.get_str(10));
    x.set_int(123456);
    println!("x={}", x.get_str(10));
    x.set_int(0xfff);
    println!("x={}", x.get_str(16));
    x.clear();
    println!("x={}", x.get_str(10));
    x.set_str("0x123", 0);
    println!("x={}", x.get_str(16));
    let buf = x.serialize();
    println!("serialize={:x?}", buf); // put hex byte
    let mut y = Fr::zero();
    if y.deserialize(&buf) {
        println!("y={}", y.get_str(16));
    } else {
        println!("err deserialize");
    }
    if x != y {
        println!("ng");
    }
    x.set_int(1);
    if x == y {
        println!("ng");
    }
    if !x.is_one() {
        println!("ng");
    }
    x.set_int(123);
    y.set_int(567);
    let mut z = unsafe { Fr::uninit() };
    Fr::add(&mut z, &x, &y);

    let x1 = Fr::from_str("1234", 10).unwrap();
    println!("x1={}", x1.get_str(10));

    println!("z={}", z.get_str(10));
    println!("x={}", x.get_str(10));
    println!("y={}", y.get_str(10));

    let mut P1 = unsafe { G1::uninit() };
    let mut P2 = unsafe { G1::uninit() };
    let mut Q1 = unsafe { G2::uninit() };
    let mut Q2 = unsafe { G2::uninit() };
    let mut e1 = unsafe { GT::uninit() };
    let mut e2 = unsafe { GT::uninit() };
    let mut e3 = unsafe { GT::uninit() };
    P1.set_hash_of("abc".as_bytes());
    Q1.set_hash_of("abc".as_bytes());
    pairing(&mut e1, &P1, &Q1);
    x.set_by_csprng();
    y.set_by_csprng();
    G1::mul(&mut P2, &P1, &x);
    G2::mul(&mut Q2, &Q1, &y);
    pairing(&mut e2, &P2, &Q2);
    GT::pow(&mut e3, &e1, &x);
    GT::pow(&mut e1, &e3, &y);
    if e1 == e2 {
        println!("ok");
    } else {
        println!("ng");
    }
}

pub fn clear(&mut self)

pub fn is_zero(&self) -> bool

impl G1

pub fn is_valid(&self) -> bool

impl G1

pub fn deserialize(&mut self, buf: &[u8]) -> bool

pub fn serialize(&self) -> Vec<u8>

impl G1

pub fn from_str(s: &str, base: i32) -> Option<G1>

pub fn set_str(&mut self, s: &str, base: i32) -> bool

pub fn get_str(&self, io_mode: i32) -> String

impl G1

pub fn add(z: &mut G1, x: &G1, y: &G1)

pub fn sub(z: &mut G1, x: &G1, y: &G1)

pub fn neg(y: &mut G1, x: &G1)

impl G1

pub fn dbl(y: &mut G1, x: &G1)

pub fn mul(z: &mut G1, x: &G1, y: &Fr)

Examples found in repository

examples/main.rs (line 63)

fn main() {
    println!("mcl version={:04x}", get_version());
    let b = init(CurveType::BN254);
    if !b {
        println!("init err");
    }
    let mut x = Fr::zero();
    println!("x={}", x.get_str(10));
    x.set_int(123456);
    println!("x={}", x.get_str(10));
    x.set_int(0xfff);
    println!("x={}", x.get_str(16));
    x.clear();
    println!("x={}", x.get_str(10));
    x.set_str("0x123", 0);
    println!("x={}", x.get_str(16));
    let buf = x.serialize();
    println!("serialize={:x?}", buf); // put hex byte
    let mut y = Fr::zero();
    if y.deserialize(&buf) {
        println!("y={}", y.get_str(16));
    } else {
        println!("err deserialize");
    }
    if x != y {
        println!("ng");
    }
    x.set_int(1);
    if x == y {
        println!("ng");
    }
    if !x.is_one() {
        println!("ng");
    }
    x.set_int(123);
    y.set_int(567);
    let mut z = unsafe { Fr::uninit() };
    Fr::add(&mut z, &x, &y);

    let x1 = Fr::from_str("1234", 10).unwrap();
    println!("x1={}", x1.get_str(10));

    println!("z={}", z.get_str(10));
    println!("x={}", x.get_str(10));
    println!("y={}", y.get_str(10));

    let mut P1 = unsafe { G1::uninit() };
    let mut P2 = unsafe { G1::uninit() };
    let mut Q1 = unsafe { G2::uninit() };
    let mut Q2 = unsafe { G2::uninit() };
    let mut e1 = unsafe { GT::uninit() };
    let mut e2 = unsafe { GT::uninit() };
    let mut e3 = unsafe { GT::uninit() };
    P1.set_hash_of("abc".as_bytes());
    Q1.set_hash_of("abc".as_bytes());
    pairing(&mut e1, &P1, &Q1);
    x.set_by_csprng();
    y.set_by_csprng();
    G1::mul(&mut P2, &P1, &x);
    G2::mul(&mut Q2, &Q1, &y);
    pairing(&mut e2, &P2, &Q2);
    GT::pow(&mut e3, &e1, &x);
    GT::pow(&mut e1, &e3, &y);
    if e1 == e2 {
        println!("ok");
    } else {
        println!("ng");
    }
}

pub fn normalize(y: &mut G1, x: &G1)

pub fn set_hash_of(&mut self, buf: &[u8]) -> bool

Examples found in repository

examples/main.rs (line 58)

fn main() {
    println!("mcl version={:04x}", get_version());
    let b = init(CurveType::BN254);
    if !b {
        println!("init err");
    }
    let mut x = Fr::zero();
    println!("x={}", x.get_str(10));
    x.set_int(123456);
    println!("x={}", x.get_str(10));
    x.set_int(0xfff);
    println!("x={}", x.get_str(16));
    x.clear();
    println!("x={}", x.get_str(10));
    x.set_str("0x123", 0);
    println!("x={}", x.get_str(16));
    let buf = x.serialize();
    println!("serialize={:x?}", buf); // put hex byte
    let mut y = Fr::zero();
    if y.deserialize(&buf) {
        println!("y={}", y.get_str(16));
    } else {
        println!("err deserialize");
    }
    if x != y {
        println!("ng");
    }
    x.set_int(1);
    if x == y {
        println!("ng");
    }
    if !x.is_one() {
        println!("ng");
    }
    x.set_int(123);
    y.set_int(567);
    let mut z = unsafe { Fr::uninit() };
    Fr::add(&mut z, &x, &y);

    let x1 = Fr::from_str("1234", 10).unwrap();
    println!("x1={}", x1.get_str(10));

    println!("z={}", z.get_str(10));
    println!("x={}", x.get_str(10));
    println!("y={}", y.get_str(10));

    let mut P1 = unsafe { G1::uninit() };
    let mut P2 = unsafe { G1::uninit() };
    let mut Q1 = unsafe { G2::uninit() };
    let mut Q2 = unsafe { G2::uninit() };
    let mut e1 = unsafe { GT::uninit() };
    let mut e2 = unsafe { GT::uninit() };
    let mut e3 = unsafe { GT::uninit() };
    P1.set_hash_of("abc".as_bytes());
    Q1.set_hash_of("abc".as_bytes());
    pairing(&mut e1, &P1, &Q1);
    x.set_by_csprng();
    y.set_by_csprng();
    G1::mul(&mut P2, &P1, &x);
    G2::mul(&mut Q2, &Q1, &y);
    pairing(&mut e2, &P2, &Q2);
    GT::pow(&mut e3, &e1, &x);
    GT::pow(&mut e1, &e3, &y);
    if e1 == e2 {
        println!("ok");
    } else {
        println!("ng");
    }
}

pub fn mul_vec(z: &mut G1, x: &[G1], y: &[Fr])

Trait Implementations

impl<'a> Add for &'a G1

type Output = G1

The resulting type after applying the + operator.

fn add(self, other: &G1) -> G1

Performs the + operation.

impl<'a> AddAssign<&'a G1> for G1

fn add_assign(&mut self, other: &G1)

Performs the += operation.

impl Clone for G1

fn clone(&self) -> G1

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for G1

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for G1

fn default() -> G1

Returns the “default value” for a type.

impl PartialEq for G1

fn eq(&self, rhs: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Sub for &'a G1

type Output = G1

The resulting type after applying the - operator.

fn sub(self, other: &G1) -> G1

Performs the - operation.

impl<'a> SubAssign<&'a G1> for G1

fn sub_assign(&mut self, other: &G1)

Performs the -= operation.