wadray

Fully qualified path: wadray

Modules

Re-exports:

• Constants

• Free functions

• Structs

• Traits

• Impls

Modules

Modules

common

Fully qualified path: wadray::common

Free functions

Free functions

Free functions

pow

Fully qualified path: wadray::common::pow

pub fn pow<T, impl TMul: Mul<T>, impl TOne: One<T>, impl TDrop: Drop<T>, impl TCopy: Copy<T>>(
    x: T, mut n: u32,
) -> T

wadray

Fully qualified path: wadray::wadray

Constants

Free functions

Structs

Impls

Constants

Constants

WAD_DECIMALS

Fully qualified path: wadray::wadray::WAD_DECIMALS

pub const WAD_DECIMALS: u8 = 18;

WAD_SCALE

Fully qualified path: wadray::wadray::WAD_SCALE

pub const WAD_SCALE: u128 = 1000000000000000000;

RAY_SCALE

Fully qualified path: wadray::wadray::RAY_SCALE

pub const RAY_SCALE: u128 = 1000000000000000000000000000;

WAD_ONE

Fully qualified path: wadray::wadray::WAD_ONE

pub const WAD_ONE: u128 = 1000000000000000000;

RAY_ONE

Fully qualified path: wadray::wadray::RAY_ONE

pub const RAY_ONE: u128 = 1000000000000000000000000000;

WAD_PERCENT

Fully qualified path: wadray::wadray::WAD_PERCENT

pub const WAD_PERCENT: u128 = 10000000000000000;

RAY_PERCENT

Fully qualified path: wadray::wadray::RAY_PERCENT

pub const RAY_PERCENT: u128 = 10000000000000000000000000;

DIFF

Fully qualified path: wadray::wadray::DIFF

pub(crate) const DIFF: u128 = 1000000000;

MAX_CONVERTIBLE_WAD

Fully qualified path: wadray::wadray::MAX_CONVERTIBLE_WAD

pub(crate) const MAX_CONVERTIBLE_WAD: u128 = 340282366920938463463374607431;

Free functions

Free functions

wmul

Fully qualified path: wadray::wadray::wmul

pub fn wmul(lhs: Wad, rhs: Wad) -> Wad

wmul_wr

Fully qualified path: wadray::wadray::wmul_wr

pub fn wmul_wr(lhs: Wad, rhs: Ray) -> Ray

wmul_rw

Fully qualified path: wadray::wadray::wmul_rw

pub fn wmul_rw(lhs: Ray, rhs: Wad) -> Ray

rmul

Fully qualified path: wadray::wadray::rmul

pub fn rmul(lhs: Ray, rhs: Ray) -> Ray

rmul_rw

Fully qualified path: wadray::wadray::rmul_rw

pub fn rmul_rw(lhs: Ray, rhs: Wad) -> Wad

rmul_wr

Fully qualified path: wadray::wadray::rmul_wr

pub fn rmul_wr(lhs: Wad, rhs: Ray) -> Wad

wdiv

Fully qualified path: wadray::wadray::wdiv

pub fn wdiv(lhs: Wad, rhs: Wad) -> Wad

wdiv_rw

Fully qualified path: wadray::wadray::wdiv_rw

pub fn wdiv_rw(lhs: Ray, rhs: Wad) -> Ray

rdiv

Fully qualified path: wadray::wadray::rdiv

pub fn rdiv(lhs: Ray, rhs: Ray) -> Ray

rdiv_wr

Fully qualified path: wadray::wadray::rdiv_wr

pub fn rdiv_wr(lhs: Wad, rhs: Ray) -> Wad

rdiv_ww

Fully qualified path: wadray::wadray::rdiv_ww

pub fn rdiv_ww(lhs: Wad, rhs: Wad) -> Ray

scale_u128_by_ray

Fully qualified path: wadray::wadray::scale_u128_by_ray

pub fn scale_u128_by_ray(lhs: u128, rhs: Ray) -> u128

div_u128_by_ray

Fully qualified path: wadray::wadray::div_u128_by_ray

pub fn div_u128_by_ray(lhs: u128, rhs: Ray) -> u128

wad_to_ray

Fully qualified path: wadray::wadray::wad_to_ray

pub fn wad_to_ray(x: Wad) -> Option<Ray>

ray_to_wad

Fully qualified path: wadray::wadray::ray_to_wad

pub fn ray_to_wad(x: Ray) -> Wad

u128_rdiv

Fully qualified path: wadray::wadray::u128_rdiv

pub(crate) fn u128_rdiv(lhs: u128, rhs: u128) -> u128

u128_rmul

Fully qualified path: wadray::wadray::u128_rmul

pub(crate) fn u128_rmul(lhs: u128, rhs: u128) -> u128

u128_wdiv

Fully qualified path: wadray::wadray::u128_wdiv

pub(crate) fn u128_wdiv(lhs: u128, rhs: u128) -> u128

u128_wmul

Fully qualified path: wadray::wadray::u128_wmul

pub(crate) fn u128_wmul(lhs: u128, rhs: u128) -> u128

Structs

Structs

Wad

Fully qualified path: wadray::wadray::Wad

[derive(Copy, Drop, Serde, starknet::Store)]
pub struct Wad { /* private fields */ }

Ray

Fully qualified path: wadray::wadray::Ray

[derive(Copy, Drop, Serde, starknet::Store)]
pub struct Ray { /* private fields */ }

Impls

Impls

WadAdd

Fully qualified path: wadray::wadray::WadAdd

pub impl WadAdd of Add<Wad>;

Impl functions

add

Fully qualified path: wadray::wadray::WadAdd::add

fn add(lhs: Wad, rhs: Wad) -> Wad

RayAdd

Fully qualified path: wadray::wadray::RayAdd

pub impl RayAdd of Add<Ray>;

Impl functions

add

Fully qualified path: wadray::wadray::RayAdd::add

fn add(lhs: Ray, rhs: Ray) -> Ray

WadAddAssign

Fully qualified path: wadray::wadray::WadAddAssign

pub impl WadAddAssign of AddAssign<Wad, Wad>;

Impl functions

add_assign

Fully qualified path: wadray::wadray::WadAddAssign::add_assign

fn add_assign(ref self: Wad, rhs: Wad)

RayAddAssign

Fully qualified path: wadray::wadray::RayAddAssign

pub impl RayAddAssign of AddAssign<Ray, Ray>;

Impl functions

add_assign

Fully qualified path: wadray::wadray::RayAddAssign::add_assign

fn add_assign(ref self: Ray, rhs: Ray)

WadSub

Fully qualified path: wadray::wadray::WadSub

pub impl WadSub of Sub<Wad>;

Impl functions

sub

Fully qualified path: wadray::wadray::WadSub::sub

fn sub(lhs: Wad, rhs: Wad) -> Wad

RaySub

Fully qualified path: wadray::wadray::RaySub

pub impl RaySub of Sub<Ray>;

Impl functions

sub

Fully qualified path: wadray::wadray::RaySub::sub

fn sub(lhs: Ray, rhs: Ray) -> Ray

WadSubAssign

Fully qualified path: wadray::wadray::WadSubAssign

pub impl WadSubAssign of SubAssign<Wad, Wad>;

Impl functions

sub_assign

Fully qualified path: wadray::wadray::WadSubAssign::sub_assign

fn sub_assign(ref self: Wad, rhs: Wad)

RaySubAssign

Fully qualified path: wadray::wadray::RaySubAssign

pub impl RaySubAssign of SubAssign<Ray, Ray>;

Impl functions

sub_assign

Fully qualified path: wadray::wadray::RaySubAssign::sub_assign

fn sub_assign(ref self: Ray, rhs: Ray)

WadMul

Fully qualified path: wadray::wadray::WadMul

pub impl WadMul of Mul<Wad>;

Impl functions

mul

Fully qualified path: wadray::wadray::WadMul::mul

fn mul(lhs: Wad, rhs: Wad) -> Wad

RayMul

Fully qualified path: wadray::wadray::RayMul

pub impl RayMul of Mul<Ray>;

Impl functions

mul

Fully qualified path: wadray::wadray::RayMul::mul

fn mul(lhs: Ray, rhs: Ray) -> Ray

WadMulAssign

Fully qualified path: wadray::wadray::WadMulAssign

pub impl WadMulAssign of MulAssign<Wad, Wad>;

Impl functions

mul_assign

Fully qualified path: wadray::wadray::WadMulAssign::mul_assign

fn mul_assign(ref self: Wad, rhs: Wad)

RayMulAssign

Fully qualified path: wadray::wadray::RayMulAssign

pub impl RayMulAssign of MulAssign<Ray, Ray>;

Impl functions

mul_assign

Fully qualified path: wadray::wadray::RayMulAssign::mul_assign

fn mul_assign(ref self: Ray, rhs: Ray)

WadDiv

Fully qualified path: wadray::wadray::WadDiv

pub impl WadDiv of Div<Wad>;

Impl functions

div

Fully qualified path: wadray::wadray::WadDiv::div

fn div(lhs: Wad, rhs: Wad) -> Wad

RayDiv

Fully qualified path: wadray::wadray::RayDiv

pub impl RayDiv of Div<Ray>;

Impl functions

div

Fully qualified path: wadray::wadray::RayDiv::div

fn div(lhs: Ray, rhs: Ray) -> Ray

WadDivAssign

Fully qualified path: wadray::wadray::WadDivAssign

pub impl WadDivAssign of DivAssign<Wad, Wad>;

Impl functions

div_assign

Fully qualified path: wadray::wadray::WadDivAssign::div_assign

fn div_assign(ref self: Wad, rhs: Wad)

RayDivAssign

Fully qualified path: wadray::wadray::RayDivAssign

pub impl RayDivAssign of DivAssign<Ray, Ray>;

Impl functions

div_assign

Fully qualified path: wadray::wadray::RayDivAssign::div_assign

fn div_assign(ref self: Ray, rhs: Ray)

TIntoWad

Fully qualified path: wadray::wadray::TIntoWad

pub impl TIntoWad<T, impl TIntoU128: Into<T, core::integer::u128>> of Into<T, Wad>;

Impl functions

into

Fully qualified path: wadray::wadray::TIntoWad::into

fn into(self: T) -> Wad

TIntoRay

Fully qualified path: wadray::wadray::TIntoRay

pub impl TIntoRay<T, impl TIntoU128: Into<T, core::integer::u128>> of Into<T, Ray>;

Impl functions

into

Fully qualified path: wadray::wadray::TIntoRay::into

fn into(self: T) -> Ray

WadIntoU128

Fully qualified path: wadray::wadray::WadIntoU128

pub impl WadIntoU128 of Into<Wad, u128>;

Impl functions

into

Fully qualified path: wadray::wadray::WadIntoU128::into

fn into(self: Wad) -> u128

WadIntoFelt252

Fully qualified path: wadray::wadray::WadIntoFelt252

pub impl WadIntoFelt252 of Into<Wad, felt252>;

Impl functions

into

Fully qualified path: wadray::wadray::WadIntoFelt252::into

fn into(self: Wad) -> felt252

WadIntoU256

Fully qualified path: wadray::wadray::WadIntoU256

pub impl WadIntoU256 of Into<Wad, u256>;

Impl functions

into

Fully qualified path: wadray::wadray::WadIntoU256::into

fn into(self: Wad) -> u256

RayIntoU128

Fully qualified path: wadray::wadray::RayIntoU128

pub impl RayIntoU128 of Into<Ray, u128>;

Impl functions

into

Fully qualified path: wadray::wadray::RayIntoU128::into

fn into(self: Ray) -> u128

RayIntoU256

Fully qualified path: wadray::wadray::RayIntoU256

pub impl RayIntoU256 of Into<Ray, u256>;

Impl functions

into

Fully qualified path: wadray::wadray::RayIntoU256::into

fn into(self: Ray) -> u256

U256TryIntoWad

Fully qualified path: wadray::wadray::U256TryIntoWad

pub impl U256TryIntoWad of TryInto<u256, Wad>;

Impl functions

try_into

Fully qualified path: wadray::wadray::U256TryIntoWad::try_into

fn try_into(self: u256) -> Option<Wad>

WadPartialEq

Fully qualified path: wadray::wadray::WadPartialEq

pub impl WadPartialEq of PartialEq<Wad>;

Impl functions

eq

Fully qualified path: wadray::wadray::WadPartialEq::eq

fn eq(lhs: @Wad, rhs: @Wad) -> bool

ne

Fully qualified path: wadray::wadray::WadPartialEq::ne

fn ne(lhs: @Wad, rhs: @Wad) -> bool

RayPartialEq

Fully qualified path: wadray::wadray::RayPartialEq

pub impl RayPartialEq of PartialEq<Ray>;

Impl functions

eq

Fully qualified path: wadray::wadray::RayPartialEq::eq

fn eq(lhs: @Ray, rhs: @Ray) -> bool

ne

Fully qualified path: wadray::wadray::RayPartialEq::ne

fn ne(lhs: @Ray, rhs: @Ray) -> bool

WadPartialOrd

Fully qualified path: wadray::wadray::WadPartialOrd

pub impl WadPartialOrd of PartialOrd<Wad>;

Impl functions

le

Fully qualified path: wadray::wadray::WadPartialOrd::le

fn le(lhs: Wad, rhs: Wad) -> bool

ge

Fully qualified path: wadray::wadray::WadPartialOrd::ge

fn ge(lhs: Wad, rhs: Wad) -> bool

lt

Fully qualified path: wadray::wadray::WadPartialOrd::lt

fn lt(lhs: Wad, rhs: Wad) -> bool

gt

Fully qualified path: wadray::wadray::WadPartialOrd::gt

fn gt(lhs: Wad, rhs: Wad) -> bool

RayPartialOrd

Fully qualified path: wadray::wadray::RayPartialOrd

pub impl RayPartialOrd of PartialOrd<Ray>;

Impl functions

le

Fully qualified path: wadray::wadray::RayPartialOrd::le

fn le(lhs: Ray, rhs: Ray) -> bool

ge

Fully qualified path: wadray::wadray::RayPartialOrd::ge

fn ge(lhs: Ray, rhs: Ray) -> bool

lt

Fully qualified path: wadray::wadray::RayPartialOrd::lt

fn lt(lhs: Ray, rhs: Ray) -> bool

gt

Fully qualified path: wadray::wadray::RayPartialOrd::gt

fn gt(lhs: Ray, rhs: Ray) -> bool

BoundedWad

Fully qualified path: wadray::wadray::BoundedWad

pub impl BoundedWad of Bounded<Wad>;

Impl constants

MIN

Fully qualified path: wadray::wadray::BoundedWad::MIN

const MIN: Wad = Wad { val: 0 };

MAX

Fully qualified path: wadray::wadray::BoundedWad::MAX

const MAX: Wad = Wad { val: Bounded::MAX };

BoundedRay

Fully qualified path: wadray::wadray::BoundedRay

pub impl BoundedRay of Bounded<Ray>;

Impl constants

MIN

Fully qualified path: wadray::wadray::BoundedRay::MIN

const MIN: Ray = Ray { val: 0 };

MAX

Fully qualified path: wadray::wadray::BoundedRay::MAX

const MAX: Ray = Ray { val: Bounded::MAX };

WadZero

Fully qualified path: wadray::wadray::WadZero

pub impl WadZero of Zero<Wad>;

Impl functions

zero

Fully qualified path: wadray::wadray::WadZero::zero

fn zero() -> Wad

is_zero

Fully qualified path: wadray::wadray::WadZero::is_zero

fn is_zero(self: @Wad) -> bool

is_non_zero

Fully qualified path: wadray::wadray::WadZero::is_non_zero

fn is_non_zero(self: @Wad) -> bool

RayZero

Fully qualified path: wadray::wadray::RayZero

pub impl RayZero of Zero<Ray>;

Impl functions

zero

Fully qualified path: wadray::wadray::RayZero::zero

fn zero() -> Ray

is_zero

Fully qualified path: wadray::wadray::RayZero::is_zero

fn is_zero(self: @Ray) -> bool

is_non_zero

Fully qualified path: wadray::wadray::RayZero::is_non_zero

fn is_non_zero(self: @Ray) -> bool

WadOne

Fully qualified path: wadray::wadray::WadOne

pub impl WadOne of One<Wad>;

Impl functions

one

Fully qualified path: wadray::wadray::WadOne::one

fn one() -> Wad

is_one

Fully qualified path: wadray::wadray::WadOne::is_one

fn is_one(self: @Wad) -> bool

is_non_one

Fully qualified path: wadray::wadray::WadOne::is_non_one

fn is_non_one(self: @Wad) -> bool

RayOne

Fully qualified path: wadray::wadray::RayOne

pub impl RayOne of One<Ray>;

Impl functions

one

Fully qualified path: wadray::wadray::RayOne::one

fn one() -> Ray

is_one

Fully qualified path: wadray::wadray::RayOne::is_one

fn is_one(self: @Ray) -> bool

is_non_one

Fully qualified path: wadray::wadray::RayOne::is_non_one

fn is_non_one(self: @Ray) -> bool

WadSqrt

Fully qualified path: wadray::wadray::WadSqrt

pub impl WadSqrt of Sqrt<Wad>;

Impl functions

sqrt

Fully qualified path: wadray::wadray::WadSqrt::sqrt

fn sqrt(self: Wad) -> Wad

Impl types

Target

Fully qualified path: wadray::wadray::WadSqrt::Target

type Target = Wad;

RaySqrt

Fully qualified path: wadray::wadray::RaySqrt

pub impl RaySqrt of Sqrt<Ray>;

Impl functions

sqrt

Fully qualified path: wadray::wadray::RaySqrt::sqrt

fn sqrt(self: Ray) -> Ray

Impl types

Target

Fully qualified path: wadray::wadray::RaySqrt::Target

type Target = Ray;

PowWad

Fully qualified path: wadray::wadray::PowWad

pub impl PowWad of Pow<Wad, u32>;

Impl functions

pow

Fully qualified path: wadray::wadray::PowWad::pow

fn pow(self: Wad, exp: u32) -> Wad

Impl types

Output

Fully qualified path: wadray::wadray::PowWad::Output

type Output = Wad;

PowRay

Fully qualified path: wadray::wadray::PowRay

pub impl PowRay of Pow<Ray, u32>;

Impl functions

pow

Fully qualified path: wadray::wadray::PowRay::pow

fn pow(self: Ray, exp: u32) -> Ray

Impl types

Output

Fully qualified path: wadray::wadray::PowRay::Output

type Output = Ray;

DisplayWad

Fully qualified path: wadray::wadray::DisplayWad

pub impl DisplayWad of Display<Wad>;

Impl functions

fmt

Fully qualified path: wadray::wadray::DisplayWad::fmt

fn fmt(self: @Wad, ref f: Formatter) -> Result<(), Error>

DisplayRay

Fully qualified path: wadray::wadray::DisplayRay

pub impl DisplayRay of Display<Ray>;

Impl functions

fmt

Fully qualified path: wadray::wadray::DisplayRay::fmt

fn fmt(self: @Ray, ref f: Formatter) -> Result<(), Error>

DebugWad

Fully qualified path: wadray::wadray::DebugWad

pub impl DebugWad of Debug<Wad>;

Impl functions

fmt

Fully qualified path: wadray::wadray::DebugWad::fmt

fn fmt(self: @Wad, ref f: Formatter) -> Result<(), Error>

DebugRay

Fully qualified path: wadray::wadray::DebugRay

pub impl DebugRay of Debug<Ray>;

Impl functions

fmt

Fully qualified path: wadray::wadray::DebugRay::fmt

fn fmt(self: @Ray, ref f: Formatter) -> Result<(), Error>

DefaultWad

Fully qualified path: wadray::wadray::DefaultWad

pub impl DefaultWad of Default<Wad>;

Impl functions

default

Fully qualified path: wadray::wadray::DefaultWad::default

fn default() -> Wad

DefaultRay

Fully qualified path: wadray::wadray::DefaultRay

pub impl DefaultRay of Default<Ray>;

Impl functions

default

Fully qualified path: wadray::wadray::DefaultRay::default

fn default() -> Ray

wadray_signed

Fully qualified path: wadray::wadray_signed

Free functions

Structs

Traits

Impls

Free functions

Free functions

wad_to_signed_ray

Fully qualified path: wadray::wadray_signed::wad_to_signed_ray

pub fn wad_to_signed_ray(a: Wad) -> SignedRay

Structs

Structs

SignedWad

Fully qualified path: wadray::wadray_signed::SignedWad

[derive(Copy, Drop, Serde)]
pub struct SignedWad { /* private fields */ }

SignedRay

Fully qualified path: wadray::wadray_signed::SignedRay

[derive(Copy, Drop, Serde)]
pub struct SignedRay { /* private fields */ }

Traits

Traits

Signed

Fully qualified path: wadray::wadray_signed::Signed

pub trait Signed<T>

Trait functions

is_negative

Fully qualified path: wadray::wadray_signed::Signed::is_negative

fn is_negative(self: T) -> bool

is_positive

Fully qualified path: wadray::wadray_signed::Signed::is_positive

fn is_positive(self: T) -> bool

Impls

Impls

SignedWadStorePacking

Fully qualified path: wadray::wadray_signed::SignedWadStorePacking

pub impl SignedWadStorePacking of StorePacking<SignedWad, felt252>;

Impl functions

pack

Fully qualified path: wadray::wadray_signed::SignedWadStorePacking::pack

fn pack(value: SignedWad) -> felt252

unpack

Fully qualified path: wadray::wadray_signed::SignedWadStorePacking::unpack

fn unpack(value: felt252) -> SignedWad

SignedRayStorePacking

Fully qualified path: wadray::wadray_signed::SignedRayStorePacking

pub impl SignedRayStorePacking of StorePacking<SignedRay, felt252>;

Impl functions

pack

Fully qualified path: wadray::wadray_signed::SignedRayStorePacking::pack

fn pack(value: SignedRay) -> felt252

unpack

Fully qualified path: wadray::wadray_signed::SignedRayStorePacking::unpack

fn unpack(value: felt252) -> SignedRay

SignedWadAdd

Fully qualified path: wadray::wadray_signed::SignedWadAdd

pub impl SignedWadAdd of Add<SignedWad>;

Impl functions

add

Fully qualified path: wadray::wadray_signed::SignedWadAdd::add

fn add(lhs: SignedWad, rhs: SignedWad) -> SignedWad

SignedWadAddAsign

Fully qualified path: wadray::wadray_signed::SignedWadAddAsign

pub impl SignedWadAddAsign of AddAssign<SignedWad, SignedWad>;

Impl functions

add_assign

Fully qualified path: wadray::wadray_signed::SignedWadAddAsign::add_assign

fn add_assign(ref self: SignedWad, rhs: SignedWad)

SignedRayAdd

Fully qualified path: wadray::wadray_signed::SignedRayAdd

pub impl SignedRayAdd of Add<SignedRay>;

Impl functions

add

Fully qualified path: wadray::wadray_signed::SignedRayAdd::add

fn add(lhs: SignedRay, rhs: SignedRay) -> SignedRay

SignedRayAddAssign

Fully qualified path: wadray::wadray_signed::SignedRayAddAssign

pub impl SignedRayAddAssign of AddAssign<SignedRay, SignedRay>;

Impl functions

add_assign

Fully qualified path: wadray::wadray_signed::SignedRayAddAssign::add_assign

fn add_assign(ref self: SignedRay, rhs: SignedRay)

SignedWadSub

Fully qualified path: wadray::wadray_signed::SignedWadSub

pub impl SignedWadSub of Sub<SignedWad>;

Impl functions

sub

Fully qualified path: wadray::wadray_signed::SignedWadSub::sub

fn sub(lhs: SignedWad, rhs: SignedWad) -> SignedWad

SignedRaySub

Fully qualified path: wadray::wadray_signed::SignedRaySub

pub impl SignedRaySub of Sub<SignedRay>;

Impl functions

sub

Fully qualified path: wadray::wadray_signed::SignedRaySub::sub

fn sub(lhs: SignedRay, rhs: SignedRay) -> SignedRay

SignedWadSubAssign

Fully qualified path: wadray::wadray_signed::SignedWadSubAssign

pub impl SignedWadSubAssign of SubAssign<SignedWad, SignedWad>;

Impl functions

sub_assign

Fully qualified path: wadray::wadray_signed::SignedWadSubAssign::sub_assign

fn sub_assign(ref self: SignedWad, rhs: SignedWad)

SignedRaySubAssign

Fully qualified path: wadray::wadray_signed::SignedRaySubAssign

pub impl SignedRaySubAssign of SubAssign<SignedRay, SignedRay>;

Impl functions

sub_assign

Fully qualified path: wadray::wadray_signed::SignedRaySubAssign::sub_assign

fn sub_assign(ref self: SignedRay, rhs: SignedRay)

SignedWadMul

Fully qualified path: wadray::wadray_signed::SignedWadMul

pub impl SignedWadMul of Mul<SignedWad>;

Impl functions

mul

Fully qualified path: wadray::wadray_signed::SignedWadMul::mul

fn mul(lhs: SignedWad, rhs: SignedWad) -> SignedWad

SignedRayMul

Fully qualified path: wadray::wadray_signed::SignedRayMul

pub impl SignedRayMul of Mul<SignedRay>;

Impl functions

mul

Fully qualified path: wadray::wadray_signed::SignedRayMul::mul

fn mul(lhs: SignedRay, rhs: SignedRay) -> SignedRay

SignedWadMulAssign

Fully qualified path: wadray::wadray_signed::SignedWadMulAssign

pub impl SignedWadMulAssign of MulAssign<SignedWad, SignedWad>;

Impl functions

mul_assign

Fully qualified path: wadray::wadray_signed::SignedWadMulAssign::mul_assign

fn mul_assign(ref self: SignedWad, rhs: SignedWad)

SignedRayMulAssign

Fully qualified path: wadray::wadray_signed::SignedRayMulAssign

pub impl SignedRayMulAssign of MulAssign<SignedRay, SignedRay>;

Impl functions

mul_assign

Fully qualified path: wadray::wadray_signed::SignedRayMulAssign::mul_assign

fn mul_assign(ref self: SignedRay, rhs: SignedRay)

SignedWadDiv

Fully qualified path: wadray::wadray_signed::SignedWadDiv

pub impl SignedWadDiv of Div<SignedWad>;

Impl functions

div

Fully qualified path: wadray::wadray_signed::SignedWadDiv::div

fn div(lhs: SignedWad, rhs: SignedWad) -> SignedWad

SignedRayDiv

Fully qualified path: wadray::wadray_signed::SignedRayDiv

pub impl SignedRayDiv of Div<SignedRay>;

Impl functions

div

Fully qualified path: wadray::wadray_signed::SignedRayDiv::div

fn div(lhs: SignedRay, rhs: SignedRay) -> SignedRay

SignedWadDivAssign

Fully qualified path: wadray::wadray_signed::SignedWadDivAssign

pub impl SignedWadDivAssign of DivAssign<SignedWad, SignedWad>;

Impl functions

div_assign

Fully qualified path: wadray::wadray_signed::SignedWadDivAssign::div_assign

fn div_assign(ref self: SignedWad, rhs: SignedWad)

SignedRayDivAssign

Fully qualified path: wadray::wadray_signed::SignedRayDivAssign

pub impl SignedRayDivAssign of DivAssign<SignedRay, SignedRay>;

Impl functions

div_assign

Fully qualified path: wadray::wadray_signed::SignedRayDivAssign::div_assign

fn div_assign(ref self: SignedRay, rhs: SignedRay)

U128IntoSignedWad

Fully qualified path: wadray::wadray_signed::U128IntoSignedWad

pub impl U128IntoSignedWad of Into<u128, SignedWad>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::U128IntoSignedWad::into

fn into(self: u128) -> SignedWad

U128IntoSignedRay

Fully qualified path: wadray::wadray_signed::U128IntoSignedRay

pub impl U128IntoSignedRay of Into<u128, SignedRay>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::U128IntoSignedRay::into

fn into(self: u128) -> SignedRay

SignedWadIntoFelt252

Fully qualified path: wadray::wadray_signed::SignedWadIntoFelt252

pub impl SignedWadIntoFelt252 of Into<SignedWad, felt252>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::SignedWadIntoFelt252::into

fn into(self: SignedWad) -> felt252

SignedRayIntoFelt252

Fully qualified path: wadray::wadray_signed::SignedRayIntoFelt252

pub impl SignedRayIntoFelt252 of Into<SignedRay, felt252>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::SignedRayIntoFelt252::into

fn into(self: SignedRay) -> felt252

WadIntoSignedWad

Fully qualified path: wadray::wadray_signed::WadIntoSignedWad

pub impl WadIntoSignedWad of Into<Wad, SignedWad>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::WadIntoSignedWad::into

fn into(self: Wad) -> SignedWad

RayIntoSignedRay

Fully qualified path: wadray::wadray_signed::RayIntoSignedRay

pub impl RayIntoSignedRay of Into<Ray, SignedRay>;

Impl functions

into

Fully qualified path: wadray::wadray_signed::RayIntoSignedRay::into

fn into(self: Ray) -> SignedRay

SignedWadTryIntoWad

Fully qualified path: wadray::wadray_signed::SignedWadTryIntoWad

pub impl SignedWadTryIntoWad of TryInto<SignedWad, Wad>;

Impl functions

try_into

Fully qualified path: wadray::wadray_signed::SignedWadTryIntoWad::try_into

fn try_into(self: SignedWad) -> Option<Wad>

SignedRayTryIntoRay

Fully qualified path: wadray::wadray_signed::SignedRayTryIntoRay

pub impl SignedRayTryIntoRay of TryInto<SignedRay, Ray>;

Impl functions

try_into

Fully qualified path: wadray::wadray_signed::SignedRayTryIntoRay::try_into

fn try_into(self: SignedRay) -> Option<Ray>

SignedWadPartialEq

Fully qualified path: wadray::wadray_signed::SignedWadPartialEq

pub impl SignedWadPartialEq of PartialEq<SignedWad>;

Impl functions

eq

Fully qualified path: wadray::wadray_signed::SignedWadPartialEq::eq

fn eq(lhs: @SignedWad, rhs: @SignedWad) -> bool

ne

Fully qualified path: wadray::wadray_signed::SignedWadPartialEq::ne

fn ne(lhs: @SignedWad, rhs: @SignedWad) -> bool

SignedWadPartialOrd

Fully qualified path: wadray::wadray_signed::SignedWadPartialOrd

pub impl SignedWadPartialOrd of PartialOrd<SignedWad>;

Impl functions

le

Fully qualified path: wadray::wadray_signed::SignedWadPartialOrd::le

fn le(lhs: SignedWad, rhs: SignedWad) -> bool

ge

Fully qualified path: wadray::wadray_signed::SignedWadPartialOrd::ge

fn ge(lhs: SignedWad, rhs: SignedWad) -> bool

lt

Fully qualified path: wadray::wadray_signed::SignedWadPartialOrd::lt

fn lt(lhs: SignedWad, rhs: SignedWad) -> bool

gt

Fully qualified path: wadray::wadray_signed::SignedWadPartialOrd::gt

fn gt(lhs: SignedWad, rhs: SignedWad) -> bool

SignedRayPartialEq

Fully qualified path: wadray::wadray_signed::SignedRayPartialEq

pub impl SignedRayPartialEq of PartialEq<SignedRay>;

Impl functions

eq

Fully qualified path: wadray::wadray_signed::SignedRayPartialEq::eq

fn eq(lhs: @SignedRay, rhs: @SignedRay) -> bool

ne

Fully qualified path: wadray::wadray_signed::SignedRayPartialEq::ne

fn ne(lhs: @SignedRay, rhs: @SignedRay) -> bool

SignedRayPartialOrd

Fully qualified path: wadray::wadray_signed::SignedRayPartialOrd

pub impl SignedRayPartialOrd of PartialOrd<SignedRay>;

Impl functions

le

Fully qualified path: wadray::wadray_signed::SignedRayPartialOrd::le

fn le(lhs: SignedRay, rhs: SignedRay) -> bool

ge

Fully qualified path: wadray::wadray_signed::SignedRayPartialOrd::ge

fn ge(lhs: SignedRay, rhs: SignedRay) -> bool

lt

Fully qualified path: wadray::wadray_signed::SignedRayPartialOrd::lt

fn lt(lhs: SignedRay, rhs: SignedRay) -> bool

gt

Fully qualified path: wadray::wadray_signed::SignedRayPartialOrd::gt

fn gt(lhs: SignedRay, rhs: SignedRay) -> bool

BoundedSignedWad

Fully qualified path: wadray::wadray_signed::BoundedSignedWad

pub impl BoundedSignedWad of Bounded<SignedWad>;

Impl constants

MAX

Fully qualified path: wadray::wadray_signed::BoundedSignedWad::MAX

const MAX: SignedWad = SignedWad { val: Bounded::MAX, sign: false };

MIN

Fully qualified path: wadray::wadray_signed::BoundedSignedWad::MIN

const MIN: SignedWad = SignedWad { val: Bounded::MAX, sign: true };

BoundedSignedRay

Fully qualified path: wadray::wadray_signed::BoundedSignedRay

pub impl BoundedSignedRay of Bounded<SignedRay>;

Impl constants

MAX

Fully qualified path: wadray::wadray_signed::BoundedSignedRay::MAX

const MAX: SignedRay = SignedRay { val: Bounded::MAX, sign: false };

MIN

Fully qualified path: wadray::wadray_signed::BoundedSignedRay::MIN

const MIN: SignedRay = SignedRay { val: Bounded::MAX, sign: true };

SignedWadZero

Fully qualified path: wadray::wadray_signed::SignedWadZero

pub impl SignedWadZero of Zero<SignedWad>;

Impl functions

zero

Fully qualified path: wadray::wadray_signed::SignedWadZero::zero

fn zero() -> SignedWad

is_zero

Fully qualified path: wadray::wadray_signed::SignedWadZero::is_zero

fn is_zero(self: @SignedWad) -> bool

is_non_zero

Fully qualified path: wadray::wadray_signed::SignedWadZero::is_non_zero

fn is_non_zero(self: @SignedWad) -> bool

SignedRayZero

Fully qualified path: wadray::wadray_signed::SignedRayZero

pub impl SignedRayZero of Zero<SignedRay>;

Impl functions

zero

Fully qualified path: wadray::wadray_signed::SignedRayZero::zero

fn zero() -> SignedRay

is_zero

Fully qualified path: wadray::wadray_signed::SignedRayZero::is_zero

fn is_zero(self: @SignedRay) -> bool

is_non_zero

Fully qualified path: wadray::wadray_signed::SignedRayZero::is_non_zero

fn is_non_zero(self: @SignedRay) -> bool

SignedWadOne

Fully qualified path: wadray::wadray_signed::SignedWadOne

pub impl SignedWadOne of One<SignedWad>;

Impl functions

one

Fully qualified path: wadray::wadray_signed::SignedWadOne::one

fn one() -> SignedWad

is_one

Fully qualified path: wadray::wadray_signed::SignedWadOne::is_one

fn is_one(self: @SignedWad) -> bool

is_non_one

Fully qualified path: wadray::wadray_signed::SignedWadOne::is_non_one

fn is_non_one(self: @SignedWad) -> bool

SignedRayOne

Fully qualified path: wadray::wadray_signed::SignedRayOne

pub impl SignedRayOne of One<SignedRay>;

Impl functions

one

Fully qualified path: wadray::wadray_signed::SignedRayOne::one

fn one() -> SignedRay

is_one

Fully qualified path: wadray::wadray_signed::SignedRayOne::is_one

fn is_one(self: @SignedRay) -> bool

is_non_one

Fully qualified path: wadray::wadray_signed::SignedRayOne::is_non_one

fn is_non_one(self: @SignedRay) -> bool

PowSignedWad

Fully qualified path: wadray::wadray_signed::PowSignedWad

pub impl PowSignedWad of Pow<SignedWad, u32>;

Impl functions

pow

Fully qualified path: wadray::wadray_signed::PowSignedWad::pow

fn pow(self: SignedWad, exp: u32) -> SignedWad

Impl types

Output

Fully qualified path: wadray::wadray_signed::PowSignedWad::Output

type Output = SignedWad;

PowSignedRay

Fully qualified path: wadray::wadray_signed::PowSignedRay

pub impl PowSignedRay of Pow<SignedRay, u32>;

Impl functions

pow

Fully qualified path: wadray::wadray_signed::PowSignedRay::pow

fn pow(self: SignedRay, exp: u32) -> SignedRay

Impl types

Output

Fully qualified path: wadray::wadray_signed::PowSignedRay::Output

type Output = SignedRay;

SignedWadSigned

Fully qualified path: wadray::wadray_signed::SignedWadSigned

pub impl SignedWadSigned of Signed<SignedWad>;

Impl functions

is_negative

Fully qualified path: wadray::wadray_signed::SignedWadSigned::is_negative

fn is_negative(self: SignedWad) -> bool

is_positive

Fully qualified path: wadray::wadray_signed::SignedWadSigned::is_positive

fn is_positive(self: SignedWad) -> bool

SignedRaySigned

Fully qualified path: wadray::wadray_signed::SignedRaySigned

pub impl SignedRaySigned of Signed<SignedRay>;

Impl functions

is_negative

Fully qualified path: wadray::wadray_signed::SignedRaySigned::is_negative

fn is_negative(self: SignedRay) -> bool

is_positive

Fully qualified path: wadray::wadray_signed::SignedRaySigned::is_positive

fn is_positive(self: SignedRay) -> bool

DisplaySignedWad

Fully qualified path: wadray::wadray_signed::DisplaySignedWad

pub impl DisplaySignedWad of Display<SignedWad>;

Impl functions

fmt

Fully qualified path: wadray::wadray_signed::DisplaySignedWad::fmt

fn fmt(self: @SignedWad, ref f: Formatter) -> Result<(), Error>

DisplaySignedRay

Fully qualified path: wadray::wadray_signed::DisplaySignedRay

pub impl DisplaySignedRay of Display<SignedRay>;

Impl functions

fmt

Fully qualified path: wadray::wadray_signed::DisplaySignedRay::fmt

fn fmt(self: @SignedRay, ref f: Formatter) -> Result<(), Error>

DebugSignedWad

Fully qualified path: wadray::wadray_signed::DebugSignedWad

pub impl DebugSignedWad of Debug<SignedWad>;

Impl functions

fmt

Fully qualified path: wadray::wadray_signed::DebugSignedWad::fmt

fn fmt(self: @SignedWad, ref f: Formatter) -> Result<(), Error>

DebugSignedRay

Fully qualified path: wadray::wadray_signed::DebugSignedRay

pub impl DebugSignedRay of Debug<SignedRay>;

Impl functions

fmt

Fully qualified path: wadray::wadray_signed::DebugSignedRay::fmt

fn fmt(self: @SignedRay, ref f: Formatter) -> Result<(), Error>

DefaultSignedWad

Fully qualified path: wadray::wadray_signed::DefaultSignedWad

pub impl DefaultSignedWad of Default<SignedWad>;

Impl functions

default

Fully qualified path: wadray::wadray_signed::DefaultSignedWad::default

fn default() -> SignedWad

DefaultSignedRay

Fully qualified path: wadray::wadray_signed::DefaultSignedRay

pub impl DefaultSignedRay of Default<SignedRay>;

Impl functions

default

Fully qualified path: wadray::wadray_signed::DefaultSignedRay::default

fn default() -> SignedRay

SignedWadNeg

Fully qualified path: wadray::wadray_signed::SignedWadNeg

pub impl SignedWadNeg of Neg<SignedWad>;

Impl functions

neg

Fully qualified path: wadray::wadray_signed::SignedWadNeg::neg

fn neg(a: SignedWad) -> SignedWad

SignedRayNeg

Fully qualified path: wadray::wadray_signed::SignedRayNeg

pub impl SignedRayNeg of Neg<SignedRay>;

Impl functions

neg

Fully qualified path: wadray::wadray_signed::SignedRayNeg::neg

fn neg(a: SignedRay) -> SignedRay