Trait snarkvm_circuit::Mul

1.0.0 · source · 
pub trait Mul<Rhs = Self> {
    type Output;

    fn mul(self, rhs: Rhs) -> Self::Output;
}
Expand description

The multiplication operator *.

Note that Rhs is Self by default, but this is not mandatory.

Examples

Multipliable rational numbers

use std::ops::Mul;

// By the fundamental theorem of arithmetic, rational numbers in lowest
// terms are unique. So, by keeping `Rational`s in reduced form, we can
// derive `Eq` and `PartialEq`.
#[derive(Debug, Eq, PartialEq)]
struct Rational {
    numerator: usize,
    denominator: usize,
}

impl Rational {
    fn new(numerator: usize, denominator: usize) -> Self {
        if denominator == 0 {
            panic!("Zero is an invalid denominator!");
        }

        // Reduce to lowest terms by dividing by the greatest common
        // divisor.
        let gcd = gcd(numerator, denominator);
        Self {
            numerator: numerator / gcd,
            denominator: denominator / gcd,
        }
    }
}

impl Mul for Rational {
    // The multiplication of rational numbers is a closed operation.
    type Output = Self;

    fn mul(self, rhs: Self) -> Self {
        let numerator = self.numerator * rhs.numerator;
        let denominator = self.denominator * rhs.denominator;
        Self::new(numerator, denominator)
    }
}

// Euclid's two-thousand-year-old algorithm for finding the greatest common
// divisor.
fn gcd(x: usize, y: usize) -> usize {
    let mut x = x;
    let mut y = y;
    while y != 0 {
        let t = y;
        y = x % y;
        x = t;
    }
    x
}

assert_eq!(Rational::new(1, 2), Rational::new(2, 4));
assert_eq!(Rational::new(2, 3) * Rational::new(3, 4),
           Rational::new(1, 2));

Multiplying vectors by scalars as in linear algebra

use std::ops::Mul;

struct Scalar { value: usize }

#[derive(Debug, PartialEq)]
struct Vector { value: Vec<usize> }

impl Mul<Scalar> for Vector {
    type Output = Self;

    fn mul(self, rhs: Scalar) -> Self::Output {
        Self { value: self.value.iter().map(|v| v * rhs.value).collect() }
    }
}

let vector = Vector { value: vec![2, 4, 6] };
let scalar = Scalar { value: 3 };
assert_eq!(vector * scalar, Vector { value: vec![6, 12, 18] });

Required Associated Types§

The resulting type after applying the * operator.

Required Methods§

Performs the * operation.

Example
assert_eq!(12 * 2, 24);

Trait Implementations§

Returns the number of constants, public inputs, private inputs, and constraints.
Returns the number of constants, public inputs, private inputs, and constraints.
Returns the mode of the output.
Returns the mode of the output.

Implementors§

UTerm * B0 = UTerm

UTerm * B1 = UTerm

Performs O(nlogn) multiplication of polynomials if F is smooth.

Multiplies self by other: F.

Multiplies self by other: F.

Z0 * I = Z0

N * Z0 = Z0

P * Z0 = Z0

UTerm * U = UTerm

UInt * B0 = UTerm

UInt * B1 = UInt

UInt<U, B> * UTerm = UTerm

UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>

UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>

N(Ul) * N(Ur) = P(Ul * Ur)

P(Ul) * N(Ur) = N(Ul * Ur)

N(Ul) * P(Ur) = N(Ul * Ur)

P(Ul) * P(Ur) = P(Ul * Ur)