Struct secp256k1::curve::Jacobian

pub struct Jacobian {
    pub x: Field,
    pub y: Field,
    pub z: Field,
    pub infinity: bool,
}

A group element of the secp256k1 curve, in jacobian coordinates.

Fields

x: Field

y: Field

z: Field

infinity: bool

Methods

impl Jacobian

pub fn set_infinity(&mut self)

Set a group element (jacobian) equal to the point at infinity.

pub fn set_ge(&mut self, a: &Affine)

Set a group element (jacobian) equal to another which is given in affine coordinates.

pub fn from_ge(a: &Affine) -> Self

pub fn eq_x_var(&self, x: &Field) -> bool

Compare the X coordinate of a group element (jacobian).

pub fn neg_in_place(&mut self, a: &Jacobian)

Set r equal to the inverse of a (i.e., mirrored around the X axis).

pub fn neg(&self) -> Jacobian

pub fn is_infinity(&self) -> bool

Check whether a group element is the point at infinity.

pub fn has_quad_y_var(&self) -> bool

Check whether a group element's y coordinate is a quadratic residue.

pub fn double_nonzero_in_place(&mut self, a: &Jacobian, rzr: Option<&mut Field>)

Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0). a may not be zero. Constant time.

pub fn double_var_in_place(&mut self, a: &Jacobian, rzr: Option<&mut Field>)

Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0).

pub fn double_var(&self, rzr: Option<&mut Field>) -> Jacobian

pub fn add_var_in_place(
    &mut self,
    a: &Jacobian,
    b: &Jacobian,
    rzr: Option<&mut Field>
)

Set r equal to the sum of a and b. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case).

pub fn add_var(&self, b: &Jacobian, rzr: Option<&mut Field>) -> Jacobian

pub fn add_ge_in_place(&mut self, a: &Jacobian, b: &Affine)

Set r equal to the sum of a and b (with b given in affine coordinates, and not infinity).

pub fn add_ge(&self, b: &Affine) -> Jacobian

pub fn add_ge_var_in_place(
    &mut self,
    a: &Jacobian,
    b: &Affine,
    rzr: Option<&mut Field>
)

Set r equal to the sum of a and b (with b given in affine coordinates). This is more efficient than secp256k1_gej_add_var. It is identical to secp256k1_gej_add_ge but without constant-time guarantee, and b is allowed to be infinity. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case).

pub fn add_ge_var(&self, b: &Affine, rzr: Option<&mut Field>) -> Jacobian

pub fn add_zinv_var_in_place(&mut self, a: &Jacobian, b: &Affine, bzinv: &Field)

Set r equal to the sum of a and b (with the inverse of b's Z coordinate passed as bzinv).

pub fn add_zinv_var(&mut self, b: &Affine, bzinv: &Field) -> Jacobian

pub fn clear(&mut self)

Clear a secp256k1_gej to prevent leaking sensitive information.

pub fn rescale(&mut self, s: &Field)

Rescale a jacobian point by b which must be non-zero. Constant-time.

Trait Implementations

impl Clone for Jacobian

fn clone(&self) -> Jacobian

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Jacobian

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

Formats the value using the given formatter.

impl Default for Jacobian

fn default() -> Jacobian

Returns the "default value" for a type.

impl Eq for Jacobian

impl PartialEq<Jacobian> for Jacobian

fn eq(&self, other: &Jacobian) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Jacobian

impl StructuralPartialEq for Jacobian