Struct DivField

pub struct DivField<L, R> { /* private fields */ }

Trait Implementations

impl<Rhs, L, R> Add<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Add<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = AddField<DivField<L, R>, Rhs>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<Rhs, L, R> BitAnd<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: BitAnd<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = BitAndField<DivField<L, R>, Rhs>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<Rhs, L, R> BitOr<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: BitOr<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = BitOrField<DivField<L, R>, Rhs>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<Rhs, L, R> BitXor<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: BitXor<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = BitXorField<DivField<L, R>, Rhs>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<L: Clone, R: Clone> Clone for DivField<L, R>

fn clone(&self) -> DivField<L, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for DivField<L, R>

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

Formats the value using the given formatter.

impl<Rhs, L, R> Div<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Div<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = DivField<DivField<L, R>, Rhs>

The resulting type after applying the / operator.

fn div(self, rhs: Rhs) -> Self::Output

Performs the / operation.

impl<Rhs, L, R> Mul<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Mul<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = MulField<DivField<L, R>, Rhs>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<L, R> Neg for DivField<L, R>

where <DivField<L, R> as ScalarField>::Scalar: Neg, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = NegField<DivField<L, R>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<L, R> Not for DivField<L, R>

where <DivField<L, R> as ScalarField>::Scalar: Not, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = NotField<DivField<L, R>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<Rhs, L, R> Rem<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Rem<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = RemField<DivField<L, R>, Rhs>

The resulting type after applying the % operator.

fn rem(self, rhs: Rhs) -> Self::Output

Performs the % operation.

impl<L, R> ScalarField for DivField<L, R>

where L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Point = <L as ScalarField>::Point

type Scalar = <<L as ScalarField>::Scalar as Div<<R as ScalarField>::Scalar>>::Output

fn value(&self, point: Self::Point) -> Self::Scalar

fn map<S, F>(self, func: F) -> MapField<Self, F>

where Self: Sized, F: Fn(Self::Scalar) -> S,

fn transform<P, F>(self, func: F) -> TransformField<Self, P, F>

where Self: Sized, F: Fn(P) -> Self::Point,

impl<Rhs, L, R> Shl<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Shl<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = ShlField<DivField<L, R>, Rhs>

The resulting type after applying the << operator.

fn shl(self, rhs: Rhs) -> Self::Output

Performs the << operation.

impl<Rhs, L, R> Shr<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Shr<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = ShrField<DivField<L, R>, Rhs>

The resulting type after applying the >> operator.

fn shr(self, rhs: Rhs) -> Self::Output

Performs the >> operation.

impl<Rhs, L, R> Sub<Rhs> for DivField<L, R>

where Rhs: ScalarField<Point = <DivField<L, R> as ScalarField>::Point>, <DivField<L, R> as ScalarField>::Scalar: Sub<Rhs::Scalar>, L: ScalarField, R: ScalarField<Point = L::Point>, L::Scalar: Div<R::Scalar>, L::Point: Clone,

type Output = SubField<DivField<L, R>, Rhs>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<L: Copy, R: Copy> Copy for DivField<L, R>