cubit

Fully qualified path: cubit

Modules


f64	—
f128	—
utils	—

Modules


f64	—
f128	—
utils	—

f64

Fully qualified path: cubit::f64

Modules


math	—
procgen	—
test	—
types	—

Modules


math	—
procgen	—
test	—
types	—

math

Fully qualified path: cubit::f64::math

Modules


comp	—
ops	—
hyp	—
lut	—
trig	—

Modules


comp	—
ops	—
hyp	—
lut	—
trig	—

comp

Fully qualified path: cubit::f64::math::comp

Free functions


max	—
min	—

Free functions


max	—
min	—

max

Fully qualified path: cubit::f64::math::comp::max

fn max(a: Fixed, b: Fixed) -> Fixed

min

Fully qualified path: cubit::f64::math::comp::min

fn min(a: Fixed, b: Fixed) -> Fixed

ops

Fully qualified path: cubit::f64::math::ops

Free functions


abs	—
add	—
ceil	—
div	—
eq	—
exp	—
exp2	—
exp2_int	—
floor	—
ge	—
gt	—
le	—
ln	—
log2	—
log10	—
lt	—
mul	—
ne	—
neg	—
pow	—
pow_int	—
rem	—
round	—
sqrt	—
sub	—

Free functions


abs	—
add	—
ceil	—
div	—
eq	—
exp	—
exp2	—
exp2_int	—
floor	—
ge	—
gt	—
le	—
ln	—
log2	—
log10	—
lt	—
mul	—
ne	—
neg	—
pow	—
pow_int	—
rem	—
round	—
sqrt	—
sub	—

abs

Fully qualified path: cubit::f64::math::ops::abs

fn abs(a: Fixed) -> Fixed

add

Fully qualified path: cubit::f64::math::ops::add

fn add(a: Fixed, b: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f64::math::ops::ceil

fn ceil(a: Fixed) -> Fixed

div

Fully qualified path: cubit::f64::math::ops::div

fn div(a: Fixed, b: Fixed) -> Fixed

eq

Fully qualified path: cubit::f64::math::ops::eq

fn eq(a: @Fixed, b: @Fixed) -> bool

exp

Fully qualified path: cubit::f64::math::ops::exp

fn exp(a: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f64::math::ops::exp2

fn exp2(a: Fixed) -> Fixed

exp2_int

Fully qualified path: cubit::f64::math::ops::exp2_int

fn exp2_int(exp: u64) -> Fixed

floor

Fully qualified path: cubit::f64::math::ops::floor

fn floor(a: Fixed) -> Fixed

ge

Fully qualified path: cubit::f64::math::ops::ge

fn ge(a: Fixed, b: Fixed) -> bool

gt

Fully qualified path: cubit::f64::math::ops::gt

fn gt(a: Fixed, b: Fixed) -> bool

le

Fully qualified path: cubit::f64::math::ops::le

fn le(a: Fixed, b: Fixed) -> bool

ln

Fully qualified path: cubit::f64::math::ops::ln

fn ln(a: Fixed) -> Fixed

log2

Fully qualified path: cubit::f64::math::ops::log2

fn log2(a: Fixed) -> Fixed

log10

Fully qualified path: cubit::f64::math::ops::log10

fn log10(a: Fixed) -> Fixed

lt

Fully qualified path: cubit::f64::math::ops::lt

fn lt(a: Fixed, b: Fixed) -> bool

mul

Fully qualified path: cubit::f64::math::ops::mul

fn mul(a: Fixed, b: Fixed) -> Fixed

ne

Fully qualified path: cubit::f64::math::ops::ne

fn ne(a: @Fixed, b: @Fixed) -> bool

neg

Fully qualified path: cubit::f64::math::ops::neg

fn neg(a: Fixed) -> Fixed

pow

Fully qualified path: cubit::f64::math::ops::pow

fn pow(a: Fixed, b: Fixed) -> Fixed

pow_int

Fully qualified path: cubit::f64::math::ops::pow_int

fn pow_int(a: Fixed, b: u64, sign: bool) -> Fixed

rem

Fully qualified path: cubit::f64::math::ops::rem

fn rem(a: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f64::math::ops::round

fn round(a: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f64::math::ops::sqrt

fn sqrt(a: Fixed) -> Fixed

sub

Fully qualified path: cubit::f64::math::ops::sub

fn sub(a: Fixed, b: Fixed) -> Fixed

hyp

Fully qualified path: cubit::f64::math::hyp

Free functions


cosh	—
sinh	—
tanh	—
acosh	—
asinh	—
atanh	—

Free functions


cosh	—
sinh	—
tanh	—
acosh	—
asinh	—
atanh	—

cosh

Fully qualified path: cubit::f64::math::hyp::cosh

fn cosh(a: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f64::math::hyp::sinh

fn sinh(a: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f64::math::hyp::tanh

fn tanh(a: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f64::math::hyp::acosh

fn acosh(a: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f64::math::hyp::asinh

fn asinh(a: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f64::math::hyp::atanh

fn atanh(a: Fixed) -> Fixed

lut

Fully qualified path: cubit::f64::math::lut

Free functions


msb	—
exp2	—
sin	—
atan	—

Free functions


msb	—
exp2	—
sin	—
atan	—

msb

Fully qualified path: cubit::f64::math::lut::msb

fn msb(whole: u64) -> (u64, u64)

exp2

Fully qualified path: cubit::f64::math::lut::exp2

fn exp2(exp: u64) -> u64

sin

Fully qualified path: cubit::f64::math::lut::sin

fn sin(a: u64) -> (u64, u64, u64)

atan

Fully qualified path: cubit::f64::math::lut::atan

fn atan(a: u64) -> (u64, u64, u64)

trig

Fully qualified path: cubit::f64::math::trig

Constants


TWO_PI	—
PI	—
HALF_PI	—

Free functions


acos	—
acos_fast	—
asin	—
asin_fast	—
atan	—
atan_fast	—
cos	—
cos_fast	—
sin	—
sin_fast	—
tan	—
tan_fast	—
_sin_loop	—

Constants


TWO_PI	—
PI	—
HALF_PI	—

TWO_PI

Fully qualified path: cubit::f64::math::trig::TWO_PI

const TWO_PI: u64 = 26986075409;

PI

Fully qualified path: cubit::f64::math::trig::PI

const PI: u64 = 13493037705;

HALF_PI

Fully qualified path: cubit::f64::math::trig::HALF_PI

const HALF_PI: u64 = 6746518852;

Free functions


acos	—
acos_fast	—
asin	—
asin_fast	—
atan	—
atan_fast	—
cos	—
cos_fast	—
sin	—
sin_fast	—
tan	—
tan_fast	—
_sin_loop	—

acos

Fully qualified path: cubit::f64::math::trig::acos

fn acos(a: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f64::math::trig::acos_fast

fn acos_fast(a: Fixed) -> Fixed

asin

Fully qualified path: cubit::f64::math::trig::asin

fn asin(a: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f64::math::trig::asin_fast

fn asin_fast(a: Fixed) -> Fixed

atan

Fully qualified path: cubit::f64::math::trig::atan

fn atan(a: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f64::math::trig::atan_fast

fn atan_fast(a: Fixed) -> Fixed

cos

Fully qualified path: cubit::f64::math::trig::cos

fn cos(a: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f64::math::trig::cos_fast

fn cos_fast(a: Fixed) -> Fixed

sin

Fully qualified path: cubit::f64::math::trig::sin

fn sin(a: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f64::math::trig::sin_fast

fn sin_fast(a: Fixed) -> Fixed

tan

Fully qualified path: cubit::f64::math::trig::tan

fn tan(a: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f64::math::trig::tan_fast

fn tan_fast(a: Fixed) -> Fixed

_sin_loop

Fully qualified path: cubit::f64::math::trig::_sin_loop

fn _sin_loop(a: Fixed, i: u64, acc: Fixed) -> Fixed

procgen

Fully qualified path: cubit::f64::procgen

Modules


rand	—
simplex3	—

Modules


rand	—
simplex3	—

rand

Fully qualified path: cubit::f64::procgen::rand

Free functions


derive	—
fixed_between	—
u64_between	—
fixed_normal_between	—
u64_normal_between	—
_fixed_normal_between_loop	—

Free functions


derive	—
fixed_between	—
u64_between	—
fixed_normal_between	—
u64_normal_between	—
_fixed_normal_between_loop	—

derive

Fully qualified path: cubit::f64::procgen::rand::derive

fn derive(seed: felt252, entropy: felt252) -> felt252

fixed_between

Fully qualified path: cubit::f64::procgen::rand::fixed_between

fn fixed_between(seed: felt252, low: Fixed, high: Fixed) -> Fixed

u64_between

Fully qualified path: cubit::f64::procgen::rand::u64_between

fn u64_between(seed: felt252, low: u64, high: u64) -> u64

fixed_normal_between

Fully qualified path: cubit::f64::procgen::rand::fixed_normal_between

fn fixed_normal_between(seed: felt252, low: Fixed, high: Fixed) -> Fixed

u64_normal_between

Fully qualified path: cubit::f64::procgen::rand::u64_normal_between

fn u64_normal_between(seed: felt252, low: u64, high: u64) -> u64

_fixed_normal_between_loop

Fully qualified path: cubit::f64::procgen::rand::_fixed_normal_between_loop

fn _fixed_normal_between_loop(
    seed: felt252, low: Fixed, high: Fixed, acc: Fixed, iter: felt252,
) -> Fixed

simplex3

Fully qualified path: cubit::f64::procgen::simplex3

Free functions


permute	—
taylor_inv_sqrt	—
step	—
noise	—
noise_octaves	—

Free functions


permute	—
taylor_inv_sqrt	—
step	—
noise	—
noise_octaves	—

permute

Fully qualified path: cubit::f64::procgen::simplex3::permute

fn permute(x: Vec4) -> Vec4

taylor_inv_sqrt

Fully qualified path: cubit::f64::procgen::simplex3::taylor_inv_sqrt

fn taylor_inv_sqrt(r: Vec4) -> Vec4

step

Fully qualified path: cubit::f64::procgen::simplex3::step

fn step(edge: Fixed, x: Fixed) -> Fixed

noise

Fully qualified path: cubit::f64::procgen::simplex3::noise

fn noise(v: Vec3) -> Fixed

noise_octaves

Fully qualified path: cubit::f64::procgen::simplex3::noise_octaves

fn noise_octaves(v: Vec3, mut octaves: u64, persistence: Fixed) -> Fixed

test

Fully qualified path: cubit::f64::test

Modules


helpers	—

Modules


helpers	—

helpers

Fully qualified path: cubit::f64::test::helpers

Constants


DEFAULT_PRECISION	—

Free functions


assert_precise	—
assert_relative	—

Constants


DEFAULT_PRECISION	—

DEFAULT_PRECISION

Fully qualified path: cubit::f64::test::helpers::DEFAULT_PRECISION

const DEFAULT_PRECISION: u64 = 430;

Free functions


assert_precise	—
assert_relative	—

assert_precise

Fully qualified path: cubit::f64::test::helpers::assert_precise

fn assert_precise(result: Fixed, expected: felt252, msg: felt252, custom_precision: Option<u64>)

assert_relative

Fully qualified path: cubit::f64::test::helpers::assert_relative

fn assert_relative(result: Fixed, expected: felt252, msg: felt252, custom_precision: Option<u64>)

types

Fully qualified path: cubit::f64::types

Modules


fixed	—
vec2	—
vec3	—
vec4	—

Modules


fixed	—
vec2	—
vec3	—
vec4	—

fixed

Fully qualified path: cubit::f64::types::fixed

Constants


TWO	—
ONE	—
HALF	—
MAX_u64	—

Structs


Fixed	—

Traits


FixedTrait	—

Impls


FixedImpl	—
FixedPrint	—
Fixed64IntoFixed128	—
FixedIntoFelt252	—
FixedTryIntoU128	—
FixedTryIntoU64	—
FixedTryIntoU32	—
FixedTryIntoU16	—
FixedTryIntoU8	—
U8IntoFixed	—
U16IntoFixed	—
U32IntoFixed	—
U64IntoFixed	—
U128TryIntoFixed	—
U256TryIntoFixed	—
I8IntoFixed	—
I16IntoFixed	—
I32IntoFixed	—
I64IntoFixed	—
I128TryIntoFixed	—
FixedPartialEq	—
FixedAdd	—
FixedAddEq	—
FixedSub	—
FixedSubEq	—
FixedMul	—
FixedMulEq	—
FixedDiv	—
FixedDivEq	—
FixedPartialOrd	—
FixedNeg	—
FixedRem	—
PackFixed	—
FixedZero	—
FixedOne	—
FixedCopy	—
FixedDrop	—
FixedSerde	—

Constants


TWO	—
ONE	—
HALF	—
MAX_u64	—

TWO

Fully qualified path: cubit::f64::types::fixed::TWO

const TWO: u64 = 8589934592;

ONE

Fully qualified path: cubit::f64::types::fixed::ONE

const ONE: u64 = 4294967296;

HALF

Fully qualified path: cubit::f64::types::fixed::HALF

const HALF: u64 = 2147483648;

MAX_u64

Fully qualified path: cubit::f64::types::fixed::MAX_u64

const MAX_u64: u128 = 18446744073709551615;

Structs


Fixed	—

Fixed

Fully qualified path: cubit::f64::types::fixed::Fixed

[derive(Copy, Drop, Serde)]
struct Fixed {
    mag: u64,
    sign: bool,
}

Members

mag

Fully qualified path: cubit::f64::types::fixed::Fixed::mag

mag: u64

sign

Fully qualified path: cubit::f64::types::fixed::Fixed::sign

sign: bool

Traits


FixedTrait	—

FixedTrait

Fully qualified path: cubit::f64::types::fixed::FixedTrait

trait FixedTrait

Trait functions

ZERO

Fully qualified path: cubit::f64::types::fixed::FixedTrait::ZERO

fn ZERO() -> Fixed

ONE

Fully qualified path: cubit::f64::types::fixed::FixedTrait::ONE

fn ONE() -> Fixed

new

Fully qualified path: cubit::f64::types::fixed::FixedTrait::new

fn new(mag: u64, sign: bool) -> Fixed

new_unscaled

Fully qualified path: cubit::f64::types::fixed::FixedTrait::new_unscaled

fn new_unscaled(mag: u64, sign: bool) -> Fixed

from_felt

Fully qualified path: cubit::f64::types::fixed::FixedTrait::from_felt

fn from_felt(val: felt252) -> Fixed

from_unscaled_felt

Fully qualified path: cubit::f64::types::fixed::FixedTrait::from_unscaled_felt

fn from_unscaled_felt(val: felt252) -> Fixed

abs

Fully qualified path: cubit::f64::types::fixed::FixedTrait::abs

fn abs(self: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f64::types::fixed::FixedTrait::ceil

fn ceil(self: Fixed) -> Fixed

exp

Fully qualified path: cubit::f64::types::fixed::FixedTrait::exp

fn exp(self: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f64::types::fixed::FixedTrait::exp2

fn exp2(self: Fixed) -> Fixed

floor

Fully qualified path: cubit::f64::types::fixed::FixedTrait::floor

fn floor(self: Fixed) -> Fixed

ln

Fully qualified path: cubit::f64::types::fixed::FixedTrait::ln

fn ln(self: Fixed) -> Fixed

log2

Fully qualified path: cubit::f64::types::fixed::FixedTrait::log2

fn log2(self: Fixed) -> Fixed

log10

Fully qualified path: cubit::f64::types::fixed::FixedTrait::log10

fn log10(self: Fixed) -> Fixed

pow

Fully qualified path: cubit::f64::types::fixed::FixedTrait::pow

fn pow(self: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f64::types::fixed::FixedTrait::round

fn round(self: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f64::types::fixed::FixedTrait::sqrt

fn sqrt(self: Fixed) -> Fixed

acos

Fully qualified path: cubit::f64::types::fixed::FixedTrait::acos

fn acos(self: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::acos_fast

fn acos_fast(self: Fixed) -> Fixed

asin

Fully qualified path: cubit::f64::types::fixed::FixedTrait::asin

fn asin(self: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::asin_fast

fn asin_fast(self: Fixed) -> Fixed

atan

Fully qualified path: cubit::f64::types::fixed::FixedTrait::atan

fn atan(self: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::atan_fast

fn atan_fast(self: Fixed) -> Fixed

cos

Fully qualified path: cubit::f64::types::fixed::FixedTrait::cos

fn cos(self: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::cos_fast

fn cos_fast(self: Fixed) -> Fixed

sin

Fully qualified path: cubit::f64::types::fixed::FixedTrait::sin

fn sin(self: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::sin_fast

fn sin_fast(self: Fixed) -> Fixed

tan

Fully qualified path: cubit::f64::types::fixed::FixedTrait::tan

fn tan(self: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f64::types::fixed::FixedTrait::tan_fast

fn tan_fast(self: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::acosh

fn acosh(self: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::asinh

fn asinh(self: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::atanh

fn atanh(self: Fixed) -> Fixed

cosh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::cosh

fn cosh(self: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::sinh

fn sinh(self: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f64::types::fixed::FixedTrait::tanh

fn tanh(self: Fixed) -> Fixed

Impls


FixedImpl	—
FixedPrint	—
Fixed64IntoFixed128	—
FixedIntoFelt252	—
FixedTryIntoU128	—
FixedTryIntoU64	—
FixedTryIntoU32	—
FixedTryIntoU16	—
FixedTryIntoU8	—
U8IntoFixed	—
U16IntoFixed	—
U32IntoFixed	—
U64IntoFixed	—
U128TryIntoFixed	—
U256TryIntoFixed	—
I8IntoFixed	—
I16IntoFixed	—
I32IntoFixed	—
I64IntoFixed	—
I128TryIntoFixed	—
FixedPartialEq	—
FixedAdd	—
FixedAddEq	—
FixedSub	—
FixedSubEq	—
FixedMul	—
FixedMulEq	—
FixedDiv	—
FixedDivEq	—
FixedPartialOrd	—
FixedNeg	—
FixedRem	—
PackFixed	—
FixedZero	—
FixedOne	—
FixedCopy	—
FixedDrop	—
FixedSerde	—

FixedImpl

Fully qualified path: cubit::f64::types::fixed::FixedImpl

impl FixedImpl of FixedTrait;

Impl functions

ZERO

Fully qualified path: cubit::f64::types::fixed::FixedImpl::ZERO

fn ZERO() -> Fixed

ONE

Fully qualified path: cubit::f64::types::fixed::FixedImpl::ONE

fn ONE() -> Fixed

new

Fully qualified path: cubit::f64::types::fixed::FixedImpl::new

fn new(mag: u64, sign: bool) -> Fixed

new_unscaled

Fully qualified path: cubit::f64::types::fixed::FixedImpl::new_unscaled

fn new_unscaled(mag: u64, sign: bool) -> Fixed

from_felt

Fully qualified path: cubit::f64::types::fixed::FixedImpl::from_felt

fn from_felt(val: felt252) -> Fixed

from_unscaled_felt

Fully qualified path: cubit::f64::types::fixed::FixedImpl::from_unscaled_felt

fn from_unscaled_felt(val: felt252) -> Fixed

abs

Fully qualified path: cubit::f64::types::fixed::FixedImpl::abs

fn abs(self: Fixed) -> Fixed

acos

Fully qualified path: cubit::f64::types::fixed::FixedImpl::acos

fn acos(self: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::acos_fast

fn acos_fast(self: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::acosh

fn acosh(self: Fixed) -> Fixed

asin

Fully qualified path: cubit::f64::types::fixed::FixedImpl::asin

fn asin(self: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::asin_fast

fn asin_fast(self: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::asinh

fn asinh(self: Fixed) -> Fixed

atan

Fully qualified path: cubit::f64::types::fixed::FixedImpl::atan

fn atan(self: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::atan_fast

fn atan_fast(self: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::atanh

fn atanh(self: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f64::types::fixed::FixedImpl::ceil

fn ceil(self: Fixed) -> Fixed

cos

Fully qualified path: cubit::f64::types::fixed::FixedImpl::cos

fn cos(self: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::cos_fast

fn cos_fast(self: Fixed) -> Fixed

cosh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::cosh

fn cosh(self: Fixed) -> Fixed

floor

Fully qualified path: cubit::f64::types::fixed::FixedImpl::floor

fn floor(self: Fixed) -> Fixed

exp

Fully qualified path: cubit::f64::types::fixed::FixedImpl::exp

fn exp(self: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f64::types::fixed::FixedImpl::exp2

fn exp2(self: Fixed) -> Fixed

ln

Fully qualified path: cubit::f64::types::fixed::FixedImpl::ln

fn ln(self: Fixed) -> Fixed

log2

Fully qualified path: cubit::f64::types::fixed::FixedImpl::log2

fn log2(self: Fixed) -> Fixed

log10

Fully qualified path: cubit::f64::types::fixed::FixedImpl::log10

fn log10(self: Fixed) -> Fixed

pow

Fully qualified path: cubit::f64::types::fixed::FixedImpl::pow

fn pow(self: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f64::types::fixed::FixedImpl::round

fn round(self: Fixed) -> Fixed

sin

Fully qualified path: cubit::f64::types::fixed::FixedImpl::sin

fn sin(self: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::sin_fast

fn sin_fast(self: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::sinh

fn sinh(self: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f64::types::fixed::FixedImpl::sqrt

fn sqrt(self: Fixed) -> Fixed

tan

Fully qualified path: cubit::f64::types::fixed::FixedImpl::tan

fn tan(self: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f64::types::fixed::FixedImpl::tan_fast

fn tan_fast(self: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f64::types::fixed::FixedImpl::tanh

fn tanh(self: Fixed) -> Fixed

FixedPrint

Fully qualified path: cubit::f64::types::fixed::FixedPrint

impl FixedPrint of PrintTrait<Fixed>;

Impl functions

print

Fully qualified path: cubit::f64::types::fixed::FixedPrint::print

fn print(self: Fixed)

Fixed64IntoFixed128

Fully qualified path: cubit::f64::types::fixed::Fixed64IntoFixed128

impl Fixed64IntoFixed128 of Into<Fixed, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::Fixed64IntoFixed128::into

fn into(self: Fixed) -> Fixed

FixedIntoFelt252

Fully qualified path: cubit::f64::types::fixed::FixedIntoFelt252

impl FixedIntoFelt252 of Into<Fixed, felt252>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::FixedIntoFelt252::into

fn into(self: Fixed) -> felt252

FixedTryIntoU128

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU128

impl FixedTryIntoU128 of TryInto<Fixed, u128>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU128::try_into

fn try_into(self: Fixed) -> Option<u128>

FixedTryIntoU64

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU64

impl FixedTryIntoU64 of TryInto<Fixed, u64>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU64::try_into

fn try_into(self: Fixed) -> Option<u64>

FixedTryIntoU32

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU32

impl FixedTryIntoU32 of TryInto<Fixed, u32>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU32::try_into

fn try_into(self: Fixed) -> Option<u32>

FixedTryIntoU16

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU16

impl FixedTryIntoU16 of TryInto<Fixed, u16>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU16::try_into

fn try_into(self: Fixed) -> Option<u16>

FixedTryIntoU8

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU8

impl FixedTryIntoU8 of TryInto<Fixed, u8>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::FixedTryIntoU8::try_into

fn try_into(self: Fixed) -> Option<u8>

U8IntoFixed

Fully qualified path: cubit::f64::types::fixed::U8IntoFixed

impl U8IntoFixed of Into<u8, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::U8IntoFixed::into

fn into(self: u8) -> Fixed

U16IntoFixed

Fully qualified path: cubit::f64::types::fixed::U16IntoFixed

impl U16IntoFixed of Into<u16, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::U16IntoFixed::into

fn into(self: u16) -> Fixed

U32IntoFixed

Fully qualified path: cubit::f64::types::fixed::U32IntoFixed

impl U32IntoFixed of Into<u32, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::U32IntoFixed::into

fn into(self: u32) -> Fixed

U64IntoFixed

Fully qualified path: cubit::f64::types::fixed::U64IntoFixed

impl U64IntoFixed of Into<u64, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::U64IntoFixed::into

fn into(self: u64) -> Fixed

U128TryIntoFixed

Fully qualified path: cubit::f64::types::fixed::U128TryIntoFixed

impl U128TryIntoFixed of TryInto<u128, Fixed>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::U128TryIntoFixed::try_into

fn try_into(self: u128) -> Option<Fixed>

U256TryIntoFixed

Fully qualified path: cubit::f64::types::fixed::U256TryIntoFixed

impl U256TryIntoFixed of TryInto<u256, Fixed>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::U256TryIntoFixed::try_into

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

I8IntoFixed

Fully qualified path: cubit::f64::types::fixed::I8IntoFixed

impl I8IntoFixed of Into<i8, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::I8IntoFixed::into

fn into(self: i8) -> Fixed

I16IntoFixed

Fully qualified path: cubit::f64::types::fixed::I16IntoFixed

impl I16IntoFixed of Into<i16, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::I16IntoFixed::into

fn into(self: i16) -> Fixed

I32IntoFixed

Fully qualified path: cubit::f64::types::fixed::I32IntoFixed

impl I32IntoFixed of Into<i32, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::I32IntoFixed::into

fn into(self: i32) -> Fixed

I64IntoFixed

Fully qualified path: cubit::f64::types::fixed::I64IntoFixed

impl I64IntoFixed of Into<i64, Fixed>;

Impl functions

into

Fully qualified path: cubit::f64::types::fixed::I64IntoFixed::into

fn into(self: i64) -> Fixed

I128TryIntoFixed

Fully qualified path: cubit::f64::types::fixed::I128TryIntoFixed

impl I128TryIntoFixed of TryInto<i128, Fixed>;

Impl functions

try_into

Fully qualified path: cubit::f64::types::fixed::I128TryIntoFixed::try_into

fn try_into(self: i128) -> Option<Fixed>

FixedPartialEq

Fully qualified path: cubit::f64::types::fixed::FixedPartialEq

impl FixedPartialEq of PartialEq<Fixed>;

Impl functions

eq

Fully qualified path: cubit::f64::types::fixed::FixedPartialEq::eq

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

ne

Fully qualified path: cubit::f64::types::fixed::FixedPartialEq::ne

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

FixedAdd

Fully qualified path: cubit::f64::types::fixed::FixedAdd

impl FixedAdd of Add<Fixed>;

Impl functions

add

Fully qualified path: cubit::f64::types::fixed::FixedAdd::add

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

FixedAddEq

Fully qualified path: cubit::f64::types::fixed::FixedAddEq

impl FixedAddEq of AddEq<Fixed>;

Impl functions

add_eq

Fully qualified path: cubit::f64::types::fixed::FixedAddEq::add_eq

fn add_eq(ref self: Fixed, other: Fixed)

FixedSub

Fully qualified path: cubit::f64::types::fixed::FixedSub

impl FixedSub of Sub<Fixed>;

Impl functions

sub

Fully qualified path: cubit::f64::types::fixed::FixedSub::sub

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

FixedSubEq

Fully qualified path: cubit::f64::types::fixed::FixedSubEq

impl FixedSubEq of SubEq<Fixed>;

Impl functions

sub_eq

Fully qualified path: cubit::f64::types::fixed::FixedSubEq::sub_eq

fn sub_eq(ref self: Fixed, other: Fixed)

FixedMul

Fully qualified path: cubit::f64::types::fixed::FixedMul

impl FixedMul of Mul<Fixed>;

Impl functions

mul

Fully qualified path: cubit::f64::types::fixed::FixedMul::mul

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

FixedMulEq

Fully qualified path: cubit::f64::types::fixed::FixedMulEq

impl FixedMulEq of MulEq<Fixed>;

Impl functions

mul_eq

Fully qualified path: cubit::f64::types::fixed::FixedMulEq::mul_eq

fn mul_eq(ref self: Fixed, other: Fixed)

FixedDiv

Fully qualified path: cubit::f64::types::fixed::FixedDiv

impl FixedDiv of Div<Fixed>;

Impl functions

div

Fully qualified path: cubit::f64::types::fixed::FixedDiv::div

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

FixedDivEq

Fully qualified path: cubit::f64::types::fixed::FixedDivEq

impl FixedDivEq of DivEq<Fixed>;

Impl functions

div_eq

Fully qualified path: cubit::f64::types::fixed::FixedDivEq::div_eq

fn div_eq(ref self: Fixed, other: Fixed)

FixedPartialOrd

Fully qualified path: cubit::f64::types::fixed::FixedPartialOrd

impl FixedPartialOrd of PartialOrd<Fixed>;

Impl functions

ge

Fully qualified path: cubit::f64::types::fixed::FixedPartialOrd::ge

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

gt

Fully qualified path: cubit::f64::types::fixed::FixedPartialOrd::gt

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

le

Fully qualified path: cubit::f64::types::fixed::FixedPartialOrd::le

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

lt

Fully qualified path: cubit::f64::types::fixed::FixedPartialOrd::lt

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

FixedNeg

Fully qualified path: cubit::f64::types::fixed::FixedNeg

impl FixedNeg of Neg<Fixed>;

Impl functions

neg

Fully qualified path: cubit::f64::types::fixed::FixedNeg::neg

fn neg(a: Fixed) -> Fixed

FixedRem

Fully qualified path: cubit::f64::types::fixed::FixedRem

impl FixedRem of Rem<Fixed>;

Impl functions

rem

Fully qualified path: cubit::f64::types::fixed::FixedRem::rem

fn rem(lhs: Fixed, rhs: Fixed) -> Fixed

PackFixed

Fully qualified path: cubit::f64::types::fixed::PackFixed

impl PackFixed of StorePacking<Fixed, felt252>;

Impl functions

pack

Fully qualified path: cubit::f64::types::fixed::PackFixed::pack

fn pack(value: Fixed) -> felt252

unpack

Fully qualified path: cubit::f64::types::fixed::PackFixed::unpack

fn unpack(value: felt252) -> Fixed

FixedZero

Fully qualified path: cubit::f64::types::fixed::FixedZero

impl FixedZero of Zero<Fixed>;

Impl functions

zero

Fully qualified path: cubit::f64::types::fixed::FixedZero::zero

fn zero() -> Fixed

is_zero

Fully qualified path: cubit::f64::types::fixed::FixedZero::is_zero

fn is_zero(self: @Fixed) -> bool

is_non_zero

Fully qualified path: cubit::f64::types::fixed::FixedZero::is_non_zero

fn is_non_zero(self: @Fixed) -> bool

FixedOne

Fully qualified path: cubit::f64::types::fixed::FixedOne

impl FixedOne of One<Fixed>;

Impl functions

one

Fully qualified path: cubit::f64::types::fixed::FixedOne::one

fn one() -> Fixed

is_one

Fully qualified path: cubit::f64::types::fixed::FixedOne::is_one

fn is_one(self: @Fixed) -> bool

is_non_one

Fully qualified path: cubit::f64::types::fixed::FixedOne::is_non_one

fn is_non_one(self: @Fixed) -> bool

FixedCopy

Fully qualified path: cubit::f64::types::fixed::FixedCopy

impl FixedCopy of Copy<Fixed>;

FixedDrop

Fully qualified path: cubit::f64::types::fixed::FixedDrop

impl FixedDrop of Drop<Fixed>;

FixedSerde

Fully qualified path: cubit::f64::types::fixed::FixedSerde

impl FixedSerde of Serde<Fixed>;

Impl functions

serialize

Fully qualified path: cubit::f64::types::fixed::FixedSerde::serialize

fn serialize(self: @Fixed, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f64::types::fixed::FixedSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Fixed>

vec2

Fully qualified path: cubit::f64::types::vec2

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec2	—

Traits


Vec2Trait	—

Impls


Vec2Impl	—
Vec2Print	—
Vec2Add	—
Vec2Div	—
Vec2Mul	—
Vec2Rem	—
Vec2Sub	—
Vec2Copy	—
Vec2Drop	—
Vec2Serde	—
Vec2Store	—

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f64::types::vec2::abs

fn abs(a: Vec2) -> Vec2

add

Fully qualified path: cubit::f64::types::vec2::add

fn add(a: Vec2, b: Vec2) -> Vec2

cross

Fully qualified path: cubit::f64::types::vec2::cross

fn cross(a: Vec2, b: Vec2) -> Fixed

div

Fully qualified path: cubit::f64::types::vec2::div

fn div(a: Vec2, b: Vec2) -> Vec2

dot

Fully qualified path: cubit::f64::types::vec2::dot

fn dot(a: Vec2, b: Vec2) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec2::floor

fn floor(a: Vec2) -> Vec2

mul

Fully qualified path: cubit::f64::types::vec2::mul

fn mul(a: Vec2, b: Vec2) -> Vec2

norm

Fully qualified path: cubit::f64::types::vec2::norm

fn norm(a: Vec2) -> Fixed

rem

Fully qualified path: cubit::f64::types::vec2::rem

fn rem(a: Vec2, b: Vec2) -> Vec2

sub

Fully qualified path: cubit::f64::types::vec2::sub

fn sub(a: Vec2, b: Vec2) -> Vec2

Structs


Vec2	—

Vec2

Fully qualified path: cubit::f64::types::vec2::Vec2

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec2 {
    x: Fixed,
    y: Fixed,
}

Members

x

Fully qualified path: cubit::f64::types::vec2::Vec2::x

x: Fixed

y

Fully qualified path: cubit::f64::types::vec2::Vec2::y

y: Fixed

Traits


Vec2Trait	—

Vec2Trait

Fully qualified path: cubit::f64::types::vec2::Vec2Trait

trait Vec2Trait

Trait functions

new

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::new

fn new(x: Fixed, y: Fixed) -> Vec2

splat

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::splat

fn splat(v: Fixed) -> Vec2

abs

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::abs

fn abs(self: Vec2) -> Vec2

cross

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::cross

fn cross(self: Vec2, rhs: Vec2) -> Fixed

dot

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::dot

fn dot(self: Vec2, rhs: Vec2) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::floor

fn floor(self: Vec2) -> Vec2

norm

Fully qualified path: cubit::f64::types::vec2::Vec2Trait::norm

fn norm(self: Vec2) -> Fixed

Impls


Vec2Impl	—
Vec2Print	—
Vec2Add	—
Vec2Div	—
Vec2Mul	—
Vec2Rem	—
Vec2Sub	—
Vec2Copy	—
Vec2Drop	—
Vec2Serde	—
Vec2Store	—

Vec2Impl

Fully qualified path: cubit::f64::types::vec2::Vec2Impl

impl Vec2Impl of Vec2Trait;

Impl functions

new

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::new

fn new(x: Fixed, y: Fixed) -> Vec2

splat

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::splat

fn splat(v: Fixed) -> Vec2

abs

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::abs

fn abs(self: Vec2) -> Vec2

cross

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::cross

fn cross(self: Vec2, rhs: Vec2) -> Fixed

dot

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::dot

fn dot(self: Vec2, rhs: Vec2) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::floor

fn floor(self: Vec2) -> Vec2

norm

Fully qualified path: cubit::f64::types::vec2::Vec2Impl::norm

fn norm(self: Vec2) -> Fixed

Vec2Print

Fully qualified path: cubit::f64::types::vec2::Vec2Print

impl Vec2Print of PrintTrait<Vec2>;

Impl functions

print

Fully qualified path: cubit::f64::types::vec2::Vec2Print::print

fn print(self: Vec2)

Vec2Add

Fully qualified path: cubit::f64::types::vec2::Vec2Add

impl Vec2Add of Add<Vec2>;

Impl functions

add

Fully qualified path: cubit::f64::types::vec2::Vec2Add::add

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

Vec2Div

Fully qualified path: cubit::f64::types::vec2::Vec2Div

impl Vec2Div of Div<Vec2>;

Impl functions

div

Fully qualified path: cubit::f64::types::vec2::Vec2Div::div

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

Vec2Mul

Fully qualified path: cubit::f64::types::vec2::Vec2Mul

impl Vec2Mul of Mul<Vec2>;

Impl functions

mul

Fully qualified path: cubit::f64::types::vec2::Vec2Mul::mul

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

Vec2Rem

Fully qualified path: cubit::f64::types::vec2::Vec2Rem

impl Vec2Rem of Rem<Vec2>;

Impl functions

rem

Fully qualified path: cubit::f64::types::vec2::Vec2Rem::rem

fn rem(lhs: Vec2, rhs: Vec2) -> Vec2

Vec2Sub

Fully qualified path: cubit::f64::types::vec2::Vec2Sub

impl Vec2Sub of Sub<Vec2>;

Impl functions

sub

Fully qualified path: cubit::f64::types::vec2::Vec2Sub::sub

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

Vec2Copy

Fully qualified path: cubit::f64::types::vec2::Vec2Copy

impl Vec2Copy of Copy<Vec2>;

Vec2Drop

Fully qualified path: cubit::f64::types::vec2::Vec2Drop

impl Vec2Drop of Drop<Vec2>;

Vec2Serde

Fully qualified path: cubit::f64::types::vec2::Vec2Serde

impl Vec2Serde of Serde<Vec2>;

Impl functions

serialize

Fully qualified path: cubit::f64::types::vec2::Vec2Serde::serialize

fn serialize(self: @Vec2, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f64::types::vec2::Vec2Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec2>

Vec2Store

Fully qualified path: cubit::f64::types::vec2::Vec2Store

impl Vec2Store of Store<Vec2>;

Impl functions

read

Fully qualified path: cubit::f64::types::vec2::Vec2Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec2, Array<felt252>>

write

Fully qualified path: cubit::f64::types::vec2::Vec2Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec2) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f64::types::vec2::Vec2Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec2, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f64::types::vec2::Vec2Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec2,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f64::types::vec2::Vec2Store::size

fn size() -> u8

vec3

Fully qualified path: cubit::f64::types::vec3

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec3	—

Traits


Vec3Trait	—

Impls


Vec3Impl	—
Vec3Print	—
Vec3Add	—
Vec3Div	—
Vec3Mul	—
Vec3Rem	—
Vec3Sub	—
Vec3Copy	—
Vec3Drop	—
Vec3Serde	—
Vec3Store	—

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f64::types::vec3::abs

fn abs(a: Vec3) -> Vec3

add

Fully qualified path: cubit::f64::types::vec3::add

fn add(a: Vec3, b: Vec3) -> Vec3

cross

Fully qualified path: cubit::f64::types::vec3::cross

fn cross(a: Vec3, b: Vec3) -> Vec3

div

Fully qualified path: cubit::f64::types::vec3::div

fn div(a: Vec3, b: Vec3) -> Vec3

dot

Fully qualified path: cubit::f64::types::vec3::dot

fn dot(a: Vec3, b: Vec3) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec3::floor

fn floor(a: Vec3) -> Vec3

mul

Fully qualified path: cubit::f64::types::vec3::mul

fn mul(a: Vec3, b: Vec3) -> Vec3

norm

Fully qualified path: cubit::f64::types::vec3::norm

fn norm(a: Vec3) -> Fixed

rem

Fully qualified path: cubit::f64::types::vec3::rem

fn rem(a: Vec3, b: Vec3) -> Vec3

sub

Fully qualified path: cubit::f64::types::vec3::sub

fn sub(a: Vec3, b: Vec3) -> Vec3

Structs


Vec3	—

Vec3

Fully qualified path: cubit::f64::types::vec3::Vec3

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec3 {
    x: Fixed,
    y: Fixed,
    z: Fixed,
}

Members

x

Fully qualified path: cubit::f64::types::vec3::Vec3::x

x: Fixed

y

Fully qualified path: cubit::f64::types::vec3::Vec3::y

y: Fixed

z

Fully qualified path: cubit::f64::types::vec3::Vec3::z

z: Fixed

Traits


Vec3Trait	—

Vec3Trait

Fully qualified path: cubit::f64::types::vec3::Vec3Trait

trait Vec3Trait

Trait functions

new

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::new

fn new(x: Fixed, y: Fixed, z: Fixed) -> Vec3

splat

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::splat

fn splat(v: Fixed) -> Vec3

abs

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::abs

fn abs(self: Vec3) -> Vec3

cross

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::cross

fn cross(self: Vec3, rhs: Vec3) -> Vec3

dot

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::dot

fn dot(self: Vec3, rhs: Vec3) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::floor

fn floor(self: Vec3) -> Vec3

norm

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::norm

fn norm(self: Vec3) -> Fixed

add

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::add

fn add(self: Vec3, scalar: Fixed) -> Vec3

sub

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::sub

fn sub(self: Vec3, scalar: Fixed) -> Vec3

mul

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::mul

fn mul(self: Vec3, scalar: Fixed) -> Vec3

div

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::div

fn div(self: Vec3, scalar: Fixed) -> Vec3

rem

Fully qualified path: cubit::f64::types::vec3::Vec3Trait::rem

fn rem(self: Vec3, scalar: Fixed) -> Vec3

Impls


Vec3Impl	—
Vec3Print	—
Vec3Add	—
Vec3Div	—
Vec3Mul	—
Vec3Rem	—
Vec3Sub	—
Vec3Copy	—
Vec3Drop	—
Vec3Serde	—
Vec3Store	—

Vec3Impl

Fully qualified path: cubit::f64::types::vec3::Vec3Impl

impl Vec3Impl of Vec3Trait;

Impl functions

new

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::new

fn new(x: Fixed, y: Fixed, z: Fixed) -> Vec3

splat

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::splat

fn splat(v: Fixed) -> Vec3

abs

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::abs

fn abs(self: Vec3) -> Vec3

cross

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::cross

fn cross(self: Vec3, rhs: Vec3) -> Vec3

dot

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::dot

fn dot(self: Vec3, rhs: Vec3) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::floor

fn floor(self: Vec3) -> Vec3

norm

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::norm

fn norm(self: Vec3) -> Fixed

add

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::add

fn add(self: Vec3, scalar: Fixed) -> Vec3

sub

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::sub

fn sub(self: Vec3, scalar: Fixed) -> Vec3

mul

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::mul

fn mul(self: Vec3, scalar: Fixed) -> Vec3

div

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::div

fn div(self: Vec3, scalar: Fixed) -> Vec3

rem

Fully qualified path: cubit::f64::types::vec3::Vec3Impl::rem

fn rem(self: Vec3, scalar: Fixed) -> Vec3

Vec3Print

Fully qualified path: cubit::f64::types::vec3::Vec3Print

impl Vec3Print of PrintTrait<Vec3>;

Impl functions

print

Fully qualified path: cubit::f64::types::vec3::Vec3Print::print

fn print(self: Vec3)

Vec3Add

Fully qualified path: cubit::f64::types::vec3::Vec3Add

impl Vec3Add of Add<Vec3>;

Impl functions

add

Fully qualified path: cubit::f64::types::vec3::Vec3Add::add

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

Vec3Div

Fully qualified path: cubit::f64::types::vec3::Vec3Div

impl Vec3Div of Div<Vec3>;

Impl functions

div

Fully qualified path: cubit::f64::types::vec3::Vec3Div::div

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

Vec3Mul

Fully qualified path: cubit::f64::types::vec3::Vec3Mul

impl Vec3Mul of Mul<Vec3>;

Impl functions

mul

Fully qualified path: cubit::f64::types::vec3::Vec3Mul::mul

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

Vec3Rem

Fully qualified path: cubit::f64::types::vec3::Vec3Rem

impl Vec3Rem of Rem<Vec3>;

Impl functions

rem

Fully qualified path: cubit::f64::types::vec3::Vec3Rem::rem

fn rem(lhs: Vec3, rhs: Vec3) -> Vec3

Vec3Sub

Fully qualified path: cubit::f64::types::vec3::Vec3Sub

impl Vec3Sub of Sub<Vec3>;

Impl functions

sub

Fully qualified path: cubit::f64::types::vec3::Vec3Sub::sub

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

Vec3Copy

Fully qualified path: cubit::f64::types::vec3::Vec3Copy

impl Vec3Copy of Copy<Vec3>;

Vec3Drop

Fully qualified path: cubit::f64::types::vec3::Vec3Drop

impl Vec3Drop of Drop<Vec3>;

Vec3Serde

Fully qualified path: cubit::f64::types::vec3::Vec3Serde

impl Vec3Serde of Serde<Vec3>;

Impl functions

serialize

Fully qualified path: cubit::f64::types::vec3::Vec3Serde::serialize

fn serialize(self: @Vec3, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f64::types::vec3::Vec3Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec3>

Vec3Store

Fully qualified path: cubit::f64::types::vec3::Vec3Store

impl Vec3Store of Store<Vec3>;

Impl functions

read

Fully qualified path: cubit::f64::types::vec3::Vec3Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec3, Array<felt252>>

write

Fully qualified path: cubit::f64::types::vec3::Vec3Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec3) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f64::types::vec3::Vec3Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec3, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f64::types::vec3::Vec3Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec3,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f64::types::vec3::Vec3Store::size

fn size() -> u8

vec4

Fully qualified path: cubit::f64::types::vec4

Free functions


abs	—
add	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec4	—

Traits


Vec4Trait	—

Impls


Vec4Impl	—
Vec4Print	—
Vec4Add	—
Vec4Div	—
Vec4Mul	—
Vec4Rem	—
Vec4Sub	—
Vec4Copy	—
Vec4Drop	—
Vec4Serde	—
Vec4Store	—

Free functions


abs	—
add	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f64::types::vec4::abs

fn abs(a: Vec4) -> Vec4

add

Fully qualified path: cubit::f64::types::vec4::add

fn add(a: Vec4, b: Vec4) -> Vec4

div

Fully qualified path: cubit::f64::types::vec4::div

fn div(a: Vec4, b: Vec4) -> Vec4

dot

Fully qualified path: cubit::f64::types::vec4::dot

fn dot(a: Vec4, b: Vec4) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec4::floor

fn floor(a: Vec4) -> Vec4

mul

Fully qualified path: cubit::f64::types::vec4::mul

fn mul(a: Vec4, b: Vec4) -> Vec4

norm

Fully qualified path: cubit::f64::types::vec4::norm

fn norm(a: Vec4) -> Fixed

rem

Fully qualified path: cubit::f64::types::vec4::rem

fn rem(a: Vec4, b: Vec4) -> Vec4

sub

Fully qualified path: cubit::f64::types::vec4::sub

fn sub(a: Vec4, b: Vec4) -> Vec4

Structs


Vec4	—

Vec4

Fully qualified path: cubit::f64::types::vec4::Vec4

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec4 {
    x: Fixed,
    y: Fixed,
    z: Fixed,
    w: Fixed,
}

Members

x

Fully qualified path: cubit::f64::types::vec4::Vec4::x

x: Fixed

y

Fully qualified path: cubit::f64::types::vec4::Vec4::y

y: Fixed

z

Fully qualified path: cubit::f64::types::vec4::Vec4::z

z: Fixed

w

Fully qualified path: cubit::f64::types::vec4::Vec4::w

w: Fixed

Traits


Vec4Trait	—

Vec4Trait

Fully qualified path: cubit::f64::types::vec4::Vec4Trait

trait Vec4Trait

Trait functions

new

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::new

fn new(x: Fixed, y: Fixed, z: Fixed, w: Fixed) -> Vec4

splat

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::splat

fn splat(v: Fixed) -> Vec4

abs

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::abs

fn abs(self: Vec4) -> Vec4

dot

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::dot

fn dot(self: Vec4, rhs: Vec4) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::floor

fn floor(self: Vec4) -> Vec4

norm

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::norm

fn norm(self: Vec4) -> Fixed

add

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::add

fn add(self: Vec4, scalar: Fixed) -> Vec4

sub

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::sub

fn sub(self: Vec4, scalar: Fixed) -> Vec4

mul

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::mul

fn mul(self: Vec4, scalar: Fixed) -> Vec4

div

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::div

fn div(self: Vec4, scalar: Fixed) -> Vec4

rem

Fully qualified path: cubit::f64::types::vec4::Vec4Trait::rem

fn rem(self: Vec4, scalar: Fixed) -> Vec4

Impls


Vec4Impl	—
Vec4Print	—
Vec4Add	—
Vec4Div	—
Vec4Mul	—
Vec4Rem	—
Vec4Sub	—
Vec4Copy	—
Vec4Drop	—
Vec4Serde	—
Vec4Store	—

Vec4Impl

Fully qualified path: cubit::f64::types::vec4::Vec4Impl

impl Vec4Impl of Vec4Trait;

Impl functions

new

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::new

fn new(x: Fixed, y: Fixed, z: Fixed, w: Fixed) -> Vec4

splat

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::splat

fn splat(v: Fixed) -> Vec4

abs

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::abs

fn abs(self: Vec4) -> Vec4

dot

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::dot

fn dot(self: Vec4, rhs: Vec4) -> Fixed

floor

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::floor

fn floor(self: Vec4) -> Vec4

norm

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::norm

fn norm(self: Vec4) -> Fixed

add

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::add

fn add(self: Vec4, scalar: Fixed) -> Vec4

sub

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::sub

fn sub(self: Vec4, scalar: Fixed) -> Vec4

mul

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::mul

fn mul(self: Vec4, scalar: Fixed) -> Vec4

div

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::div

fn div(self: Vec4, scalar: Fixed) -> Vec4

rem

Fully qualified path: cubit::f64::types::vec4::Vec4Impl::rem

fn rem(self: Vec4, scalar: Fixed) -> Vec4

Vec4Print

Fully qualified path: cubit::f64::types::vec4::Vec4Print

impl Vec4Print of PrintTrait<Vec4>;

Impl functions

print

Fully qualified path: cubit::f64::types::vec4::Vec4Print::print

fn print(self: Vec4)

Vec4Add

Fully qualified path: cubit::f64::types::vec4::Vec4Add

impl Vec4Add of Add<Vec4>;

Impl functions

add

Fully qualified path: cubit::f64::types::vec4::Vec4Add::add

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

Vec4Div

Fully qualified path: cubit::f64::types::vec4::Vec4Div

impl Vec4Div of Div<Vec4>;

Impl functions

div

Fully qualified path: cubit::f64::types::vec4::Vec4Div::div

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

Vec4Mul

Fully qualified path: cubit::f64::types::vec4::Vec4Mul

impl Vec4Mul of Mul<Vec4>;

Impl functions

mul

Fully qualified path: cubit::f64::types::vec4::Vec4Mul::mul

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

Vec4Rem

Fully qualified path: cubit::f64::types::vec4::Vec4Rem

impl Vec4Rem of Rem<Vec4>;

Impl functions

rem

Fully qualified path: cubit::f64::types::vec4::Vec4Rem::rem

fn rem(lhs: Vec4, rhs: Vec4) -> Vec4

Vec4Sub

Fully qualified path: cubit::f64::types::vec4::Vec4Sub

impl Vec4Sub of Sub<Vec4>;

Impl functions

sub

Fully qualified path: cubit::f64::types::vec4::Vec4Sub::sub

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

Vec4Copy

Fully qualified path: cubit::f64::types::vec4::Vec4Copy

impl Vec4Copy of Copy<Vec4>;

Vec4Drop

Fully qualified path: cubit::f64::types::vec4::Vec4Drop

impl Vec4Drop of Drop<Vec4>;

Vec4Serde

Fully qualified path: cubit::f64::types::vec4::Vec4Serde

impl Vec4Serde of Serde<Vec4>;

Impl functions

serialize

Fully qualified path: cubit::f64::types::vec4::Vec4Serde::serialize

fn serialize(self: @Vec4, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f64::types::vec4::Vec4Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec4>

Vec4Store

Fully qualified path: cubit::f64::types::vec4::Vec4Store

impl Vec4Store of Store<Vec4>;

Impl functions

read

Fully qualified path: cubit::f64::types::vec4::Vec4Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec4, Array<felt252>>

write

Fully qualified path: cubit::f64::types::vec4::Vec4Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec4) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f64::types::vec4::Vec4Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec4, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f64::types::vec4::Vec4Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec4,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f64::types::vec4::Vec4Store::size

fn size() -> u8

f128

Fully qualified path: cubit::f128

Modules


math	—
procgen	—
test	—
types	—

Modules


math	—
procgen	—
test	—
types	—

math

Fully qualified path: cubit::f128::math

Modules


comp	—
ops	—
hyp	—
lut	—
trig	—

Modules


comp	—
ops	—
hyp	—
lut	—
trig	—

comp

Fully qualified path: cubit::f128::math::comp

Free functions


max	—
min	—

Free functions


max	—
min	—

max

Fully qualified path: cubit::f128::math::comp::max

fn max(a: Fixed, b: Fixed) -> Fixed

min

Fully qualified path: cubit::f128::math::comp::min

fn min(a: Fixed, b: Fixed) -> Fixed

ops

Fully qualified path: cubit::f128::math::ops

Free functions


abs	—
add	—
ceil	—
div	—
eq	—
exp	—
exp2	—
exp2_int	—
floor	—
ge	—
gt	—
le	—
ln	—
log2	—
log10	—
lt	—
mul	—
mul_64	—
ne	—
neg	—
pow	—
pow_int	—
rem	—
round	—
sqrt	—
sub	—
_split_unsigned	—

Structs


f64	—

Impls


f64Copy	—
f64Drop	—
f64Serde	—

Free functions


abs	—
add	—
ceil	—
div	—
eq	—
exp	—
exp2	—
exp2_int	—
floor	—
ge	—
gt	—
le	—
ln	—
log2	—
log10	—
lt	—
mul	—
mul_64	—
ne	—
neg	—
pow	—
pow_int	—
rem	—
round	—
sqrt	—
sub	—
_split_unsigned	—

abs

Fully qualified path: cubit::f128::math::ops::abs

fn abs(a: Fixed) -> Fixed

add

Fully qualified path: cubit::f128::math::ops::add

fn add(a: Fixed, b: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f128::math::ops::ceil

fn ceil(a: Fixed) -> Fixed

div

Fully qualified path: cubit::f128::math::ops::div

fn div(a: Fixed, b: Fixed) -> Fixed

eq

Fully qualified path: cubit::f128::math::ops::eq

fn eq(a: @Fixed, b: @Fixed) -> bool

exp

Fully qualified path: cubit::f128::math::ops::exp

fn exp(a: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f128::math::ops::exp2

fn exp2(a: Fixed) -> Fixed

exp2_int

Fully qualified path: cubit::f128::math::ops::exp2_int

fn exp2_int(exp: u128) -> Fixed

floor

Fully qualified path: cubit::f128::math::ops::floor

fn floor(a: Fixed) -> Fixed

ge

Fully qualified path: cubit::f128::math::ops::ge

fn ge(a: Fixed, b: Fixed) -> bool

gt

Fully qualified path: cubit::f128::math::ops::gt

fn gt(a: Fixed, b: Fixed) -> bool

le

Fully qualified path: cubit::f128::math::ops::le

fn le(a: Fixed, b: Fixed) -> bool

ln

Fully qualified path: cubit::f128::math::ops::ln

fn ln(a: Fixed) -> Fixed

log2

Fully qualified path: cubit::f128::math::ops::log2

fn log2(a: Fixed) -> Fixed

log10

Fully qualified path: cubit::f128::math::ops::log10

fn log10(a: Fixed) -> Fixed

lt

Fully qualified path: cubit::f128::math::ops::lt

fn lt(a: Fixed, b: Fixed) -> bool

mul

Fully qualified path: cubit::f128::math::ops::mul

fn mul(a: Fixed, b: Fixed) -> Fixed

mul_64

Fully qualified path: cubit::f128::math::ops::mul_64

fn mul_64(a: f64, b: f64) -> f64

ne

Fully qualified path: cubit::f128::math::ops::ne

fn ne(a: @Fixed, b: @Fixed) -> bool

neg

Fully qualified path: cubit::f128::math::ops::neg

fn neg(a: Fixed) -> Fixed

pow

Fully qualified path: cubit::f128::math::ops::pow

fn pow(a: Fixed, b: Fixed) -> Fixed

pow_int

Fully qualified path: cubit::f128::math::ops::pow_int

fn pow_int(a: Fixed, b: u128, sign: bool) -> Fixed

rem

Fully qualified path: cubit::f128::math::ops::rem

fn rem(a: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f128::math::ops::round

fn round(a: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f128::math::ops::sqrt

fn sqrt(a: Fixed) -> Fixed

sub

Fully qualified path: cubit::f128::math::ops::sub

fn sub(a: Fixed, b: Fixed) -> Fixed

_split_unsigned

Fully qualified path: cubit::f128::math::ops::_split_unsigned

fn _split_unsigned(a: Fixed) -> (u128, u128)

Structs


f64	—

f64

Fully qualified path: cubit::f128::math::ops::f64

[derive(Copy, Drop, Serde)]
struct f64 {
    mag: u64,
    sign: bool,
}

Members

mag

Fully qualified path: cubit::f128::math::ops::f64::mag

mag: u64

sign

Fully qualified path: cubit::f128::math::ops::f64::sign

sign: bool

Impls


f64Copy	—
f64Drop	—
f64Serde	—

f64Copy

Fully qualified path: cubit::f128::math::ops::f64Copy

impl f64Copy of Copy<f64>;

f64Drop

Fully qualified path: cubit::f128::math::ops::f64Drop

impl f64Drop of Drop<f64>;

f64Serde

Fully qualified path: cubit::f128::math::ops::f64Serde

impl f64Serde of Serde<f64>;

Impl functions

serialize

Fully qualified path: cubit::f128::math::ops::f64Serde::serialize

fn serialize(self: @f64, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f128::math::ops::f64Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<f64>

hyp

Fully qualified path: cubit::f128::math::hyp

Free functions


cosh	—
sinh	—
tanh	—
acosh	—
asinh	—
atanh	—

Free functions


cosh	—
sinh	—
tanh	—
acosh	—
asinh	—
atanh	—

cosh

Fully qualified path: cubit::f128::math::hyp::cosh

fn cosh(a: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f128::math::hyp::sinh

fn sinh(a: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f128::math::hyp::tanh

fn tanh(a: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f128::math::hyp::acosh

fn acosh(a: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f128::math::hyp::asinh

fn asinh(a: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f128::math::hyp::atanh

fn atanh(a: Fixed) -> Fixed

lut

Fully qualified path: cubit::f128::math::lut

Free functions


msb	—
exp2	—
sin	—
atan	—

Free functions


msb	—
exp2	—
sin	—
atan	—

msb

Fully qualified path: cubit::f128::math::lut::msb

fn msb(whole: u128) -> (u128, u128)

exp2

Fully qualified path: cubit::f128::math::lut::exp2

fn exp2(exp: u128) -> u128

sin

Fully qualified path: cubit::f128::math::lut::sin

fn sin(a: u128) -> (u128, u128, u128)

atan

Fully qualified path: cubit::f128::math::lut::atan

fn atan(a: u128) -> (u128, u128, u128)

trig

Fully qualified path: cubit::f128::math::trig

Constants


PI_u128	—
HALF_PI_u128	—

Free functions


acos	—
acos_fast	—
asin	—
asin_fast	—
atan	—
atan_fast	—
cos	—
cos_fast	—
sin	—
sin_fast	—
tan	—
tan_fast	—
_sin_loop	—

Constants


PI_u128	—
HALF_PI_u128	—

PI_u128

Fully qualified path: cubit::f128::math::trig::PI_u128

const PI_u128: u128 = 57952155664616982739;

HALF_PI_u128

Fully qualified path: cubit::f128::math::trig::HALF_PI_u128

const HALF_PI_u128: u128 = 28976077832308491370;

Free functions


acos	—
acos_fast	—
asin	—
asin_fast	—
atan	—
atan_fast	—
cos	—
cos_fast	—
sin	—
sin_fast	—
tan	—
tan_fast	—
_sin_loop	—

acos

Fully qualified path: cubit::f128::math::trig::acos

fn acos(a: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f128::math::trig::acos_fast

fn acos_fast(a: Fixed) -> Fixed

asin

Fully qualified path: cubit::f128::math::trig::asin

fn asin(a: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f128::math::trig::asin_fast

fn asin_fast(a: Fixed) -> Fixed

atan

Fully qualified path: cubit::f128::math::trig::atan

fn atan(a: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f128::math::trig::atan_fast

fn atan_fast(a: Fixed) -> Fixed

cos

Fully qualified path: cubit::f128::math::trig::cos

fn cos(a: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f128::math::trig::cos_fast

fn cos_fast(a: Fixed) -> Fixed

sin

Fully qualified path: cubit::f128::math::trig::sin

fn sin(a: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f128::math::trig::sin_fast

fn sin_fast(a: Fixed) -> Fixed

tan

Fully qualified path: cubit::f128::math::trig::tan

fn tan(a: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f128::math::trig::tan_fast

fn tan_fast(a: Fixed) -> Fixed

_sin_loop

Fully qualified path: cubit::f128::math::trig::_sin_loop

fn _sin_loop(a: Fixed, i: u128, acc: Fixed) -> Fixed

procgen

Fully qualified path: cubit::f128::procgen

Modules


rand	—
simplex3	—

Modules


rand	—
simplex3	—

rand

Fully qualified path: cubit::f128::procgen::rand

Free functions


derive	—
fixed_between	—
u128_between	—
fixed_normal_between	—
u128_normal_between	—
_fixed_normal_between_loop	—

Free functions


derive	—
fixed_between	—
u128_between	—
fixed_normal_between	—
u128_normal_between	—
_fixed_normal_between_loop	—

derive

Fully qualified path: cubit::f128::procgen::rand::derive

fn derive(seed: felt252, entropy: felt252) -> felt252

fixed_between

Fully qualified path: cubit::f128::procgen::rand::fixed_between

fn fixed_between(seed: felt252, low: Fixed, high: Fixed) -> Fixed

u128_between

Fully qualified path: cubit::f128::procgen::rand::u128_between

fn u128_between(seed: felt252, low: u128, high: u128) -> u128

fixed_normal_between

Fully qualified path: cubit::f128::procgen::rand::fixed_normal_between

fn fixed_normal_between(seed: felt252, low: Fixed, high: Fixed) -> Fixed

u128_normal_between

Fully qualified path: cubit::f128::procgen::rand::u128_normal_between

fn u128_normal_between(seed: felt252, low: u128, high: u128) -> u128

_fixed_normal_between_loop

Fully qualified path: cubit::f128::procgen::rand::_fixed_normal_between_loop

fn _fixed_normal_between_loop(
    seed: felt252, low: Fixed, high: Fixed, acc: Fixed, iter: felt252,
) -> Fixed

simplex3

Fully qualified path: cubit::f128::procgen::simplex3

Free functions


permute	—
taylor_inv_sqrt	—
step	—
noise	—
noise_octaves	—

Free functions


permute	—
taylor_inv_sqrt	—
step	—
noise	—
noise_octaves	—

permute

Fully qualified path: cubit::f128::procgen::simplex3::permute

fn permute(x: Vec4) -> Vec4

taylor_inv_sqrt

Fully qualified path: cubit::f128::procgen::simplex3::taylor_inv_sqrt

fn taylor_inv_sqrt(r: Vec4) -> Vec4

step

Fully qualified path: cubit::f128::procgen::simplex3::step

fn step(edge: Fixed, x: Fixed) -> Fixed

noise

Fully qualified path: cubit::f128::procgen::simplex3::noise

fn noise(v: Vec3) -> Fixed

noise_octaves

Fully qualified path: cubit::f128::procgen::simplex3::noise_octaves

fn noise_octaves(v: Vec3, mut octaves: u128, persistence: Fixed) -> Fixed

test

Fully qualified path: cubit::f128::test

Modules


helpers	—

Modules


helpers	—

helpers

Fully qualified path: cubit::f128::test::helpers

Constants


DEFAULT_PRECISION	—

Free functions


assert_precise	—
assert_relative	—

Constants


DEFAULT_PRECISION	—

DEFAULT_PRECISION

Fully qualified path: cubit::f128::test::helpers::DEFAULT_PRECISION

const DEFAULT_PRECISION: u128 = 1844674407370;

Free functions


assert_precise	—
assert_relative	—

assert_precise

Fully qualified path: cubit::f128::test::helpers::assert_precise

fn assert_precise(result: Fixed, expected: felt252, msg: felt252, custom_precision: Option<u128>)

assert_relative

Fully qualified path: cubit::f128::test::helpers::assert_relative

fn assert_relative(result: Fixed, expected: felt252, msg: felt252, custom_precision: Option<u128>)

types

Fully qualified path: cubit::f128::types

Modules


fixed	—
vec2	—
vec3	—
vec4	—

Modules


fixed	—
vec2	—
vec3	—
vec4	—

fixed

Fully qualified path: cubit::f128::types::fixed

Constants


PRIME	—
ONE	—
ONE_u128	—
HALF	—
HALF_u128	—
MAX_u128	—

Structs


Fixed	—

Traits


FixedTrait	—

Impls


FixedImpl	—
Fixed128TryIntoFixed64	—
FixedPrint	—
FixedInto	—
FixedTryIntoU128	—
FixedTryIntoU64	—
FixedTryIntoU32	—
FixedTryIntoU16	—
FixedTryIntoU8	—
U8IntoFixed	—
U16IntoFixed	—
U32IntoFixed	—
U64IntoFixed	—
U128IntoFixed	—
U256TryIntoFixed	—
I8IntoFixed	—
I16IntoFixed	—
I32IntoFixed	—
I64IntoFixed	—
I128IntoFixed	—
FixedPartialEq	—
FixedAdd	—
FixedAddEq	—
FixedSub	—
FixedSubEq	—
FixedMul	—
FixedMulEq	—
FixedDiv	—
FixedDivEq	—
FixedPartialOrd	—
FixedNeg	—
FixedRem	—
PackFixed	—
FixedZero	—
FixedOne	—
FixedCopy	—
FixedDrop	—
FixedSerde	—

Constants


PRIME	—
ONE	—
ONE_u128	—
HALF	—
HALF_u128	—
MAX_u128	—

PRIME

Fully qualified path: cubit::f128::types::fixed::PRIME

const PRIME: felt252 = 3618502788666131213697322783095070105623107215331596699973092056135872020480;

ONE

Fully qualified path: cubit::f128::types::fixed::ONE

const ONE: felt252 = 18446744073709551616;

ONE_u128

Fully qualified path: cubit::f128::types::fixed::ONE_u128

const ONE_u128: u128 = 18446744073709551616;

HALF

Fully qualified path: cubit::f128::types::fixed::HALF

const HALF: felt252 = 9223372036854775808;

HALF_u128

Fully qualified path: cubit::f128::types::fixed::HALF_u128

const HALF_u128: u128 = 9223372036854775808;

MAX_u128

Fully qualified path: cubit::f128::types::fixed::MAX_u128

const MAX_u128: u128 = 340282366920938463463374607431768211455;

Structs


Fixed	—

Fixed

Fully qualified path: cubit::f128::types::fixed::Fixed

[derive(Copy, Drop, Serde)]
struct Fixed {
    mag: u128,
    sign: bool,
}

Members

mag

Fully qualified path: cubit::f128::types::fixed::Fixed::mag

mag: u128

sign

Fully qualified path: cubit::f128::types::fixed::Fixed::sign

sign: bool

Traits


FixedTrait	—

FixedTrait

Fully qualified path: cubit::f128::types::fixed::FixedTrait

trait FixedTrait

Trait functions

ZERO

Fully qualified path: cubit::f128::types::fixed::FixedTrait::ZERO

fn ZERO() -> Fixed

ONE

Fully qualified path: cubit::f128::types::fixed::FixedTrait::ONE

fn ONE() -> Fixed

new

Fully qualified path: cubit::f128::types::fixed::FixedTrait::new

fn new(mag: u128, sign: bool) -> Fixed

new_unscaled

Fully qualified path: cubit::f128::types::fixed::FixedTrait::new_unscaled

fn new_unscaled(mag: u128, sign: bool) -> Fixed

from_felt

Fully qualified path: cubit::f128::types::fixed::FixedTrait::from_felt

fn from_felt(val: felt252) -> Fixed

from_unscaled_felt

Fully qualified path: cubit::f128::types::fixed::FixedTrait::from_unscaled_felt

fn from_unscaled_felt(val: felt252) -> Fixed

abs

Fully qualified path: cubit::f128::types::fixed::FixedTrait::abs

fn abs(self: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f128::types::fixed::FixedTrait::ceil

fn ceil(self: Fixed) -> Fixed

exp

Fully qualified path: cubit::f128::types::fixed::FixedTrait::exp

fn exp(self: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f128::types::fixed::FixedTrait::exp2

fn exp2(self: Fixed) -> Fixed

floor

Fully qualified path: cubit::f128::types::fixed::FixedTrait::floor

fn floor(self: Fixed) -> Fixed

ln

Fully qualified path: cubit::f128::types::fixed::FixedTrait::ln

fn ln(self: Fixed) -> Fixed

log2

Fully qualified path: cubit::f128::types::fixed::FixedTrait::log2

fn log2(self: Fixed) -> Fixed

log10

Fully qualified path: cubit::f128::types::fixed::FixedTrait::log10

fn log10(self: Fixed) -> Fixed

pow

Fully qualified path: cubit::f128::types::fixed::FixedTrait::pow

fn pow(self: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f128::types::fixed::FixedTrait::round

fn round(self: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f128::types::fixed::FixedTrait::sqrt

fn sqrt(self: Fixed) -> Fixed

acos

Fully qualified path: cubit::f128::types::fixed::FixedTrait::acos

fn acos(self: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::acos_fast

fn acos_fast(self: Fixed) -> Fixed

asin

Fully qualified path: cubit::f128::types::fixed::FixedTrait::asin

fn asin(self: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::asin_fast

fn asin_fast(self: Fixed) -> Fixed

atan

Fully qualified path: cubit::f128::types::fixed::FixedTrait::atan

fn atan(self: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::atan_fast

fn atan_fast(self: Fixed) -> Fixed

cos

Fully qualified path: cubit::f128::types::fixed::FixedTrait::cos

fn cos(self: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::cos_fast

fn cos_fast(self: Fixed) -> Fixed

sin

Fully qualified path: cubit::f128::types::fixed::FixedTrait::sin

fn sin(self: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::sin_fast

fn sin_fast(self: Fixed) -> Fixed

tan

Fully qualified path: cubit::f128::types::fixed::FixedTrait::tan

fn tan(self: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f128::types::fixed::FixedTrait::tan_fast

fn tan_fast(self: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::acosh

fn acosh(self: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::asinh

fn asinh(self: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::atanh

fn atanh(self: Fixed) -> Fixed

cosh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::cosh

fn cosh(self: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::sinh

fn sinh(self: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f128::types::fixed::FixedTrait::tanh

fn tanh(self: Fixed) -> Fixed

Impls


FixedImpl	—
Fixed128TryIntoFixed64	—
FixedPrint	—
FixedInto	—
FixedTryIntoU128	—
FixedTryIntoU64	—
FixedTryIntoU32	—
FixedTryIntoU16	—
FixedTryIntoU8	—
U8IntoFixed	—
U16IntoFixed	—
U32IntoFixed	—
U64IntoFixed	—
U128IntoFixed	—
U256TryIntoFixed	—
I8IntoFixed	—
I16IntoFixed	—
I32IntoFixed	—
I64IntoFixed	—
I128IntoFixed	—
FixedPartialEq	—
FixedAdd	—
FixedAddEq	—
FixedSub	—
FixedSubEq	—
FixedMul	—
FixedMulEq	—
FixedDiv	—
FixedDivEq	—
FixedPartialOrd	—
FixedNeg	—
FixedRem	—
PackFixed	—
FixedZero	—
FixedOne	—
FixedCopy	—
FixedDrop	—
FixedSerde	—

FixedImpl

Fully qualified path: cubit::f128::types::fixed::FixedImpl

impl FixedImpl of FixedTrait;

Impl functions

ZERO

Fully qualified path: cubit::f128::types::fixed::FixedImpl::ZERO

fn ZERO() -> Fixed

ONE

Fully qualified path: cubit::f128::types::fixed::FixedImpl::ONE

fn ONE() -> Fixed

new

Fully qualified path: cubit::f128::types::fixed::FixedImpl::new

fn new(mag: u128, sign: bool) -> Fixed

new_unscaled

Fully qualified path: cubit::f128::types::fixed::FixedImpl::new_unscaled

fn new_unscaled(mag: u128, sign: bool) -> Fixed

from_felt

Fully qualified path: cubit::f128::types::fixed::FixedImpl::from_felt

fn from_felt(val: felt252) -> Fixed

from_unscaled_felt

Fully qualified path: cubit::f128::types::fixed::FixedImpl::from_unscaled_felt

fn from_unscaled_felt(val: felt252) -> Fixed

abs

Fully qualified path: cubit::f128::types::fixed::FixedImpl::abs

fn abs(self: Fixed) -> Fixed

acos

Fully qualified path: cubit::f128::types::fixed::FixedImpl::acos

fn acos(self: Fixed) -> Fixed

acos_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::acos_fast

fn acos_fast(self: Fixed) -> Fixed

acosh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::acosh

fn acosh(self: Fixed) -> Fixed

asin

Fully qualified path: cubit::f128::types::fixed::FixedImpl::asin

fn asin(self: Fixed) -> Fixed

asin_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::asin_fast

fn asin_fast(self: Fixed) -> Fixed

asinh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::asinh

fn asinh(self: Fixed) -> Fixed

atan

Fully qualified path: cubit::f128::types::fixed::FixedImpl::atan

fn atan(self: Fixed) -> Fixed

atan_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::atan_fast

fn atan_fast(self: Fixed) -> Fixed

atanh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::atanh

fn atanh(self: Fixed) -> Fixed

ceil

Fully qualified path: cubit::f128::types::fixed::FixedImpl::ceil

fn ceil(self: Fixed) -> Fixed

cos

Fully qualified path: cubit::f128::types::fixed::FixedImpl::cos

fn cos(self: Fixed) -> Fixed

cos_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::cos_fast

fn cos_fast(self: Fixed) -> Fixed

cosh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::cosh

fn cosh(self: Fixed) -> Fixed

floor

Fully qualified path: cubit::f128::types::fixed::FixedImpl::floor

fn floor(self: Fixed) -> Fixed

exp

Fully qualified path: cubit::f128::types::fixed::FixedImpl::exp

fn exp(self: Fixed) -> Fixed

exp2

Fully qualified path: cubit::f128::types::fixed::FixedImpl::exp2

fn exp2(self: Fixed) -> Fixed

ln

Fully qualified path: cubit::f128::types::fixed::FixedImpl::ln

fn ln(self: Fixed) -> Fixed

log2

Fully qualified path: cubit::f128::types::fixed::FixedImpl::log2

fn log2(self: Fixed) -> Fixed

log10

Fully qualified path: cubit::f128::types::fixed::FixedImpl::log10

fn log10(self: Fixed) -> Fixed

pow

Fully qualified path: cubit::f128::types::fixed::FixedImpl::pow

fn pow(self: Fixed, b: Fixed) -> Fixed

round

Fully qualified path: cubit::f128::types::fixed::FixedImpl::round

fn round(self: Fixed) -> Fixed

sin

Fully qualified path: cubit::f128::types::fixed::FixedImpl::sin

fn sin(self: Fixed) -> Fixed

sin_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::sin_fast

fn sin_fast(self: Fixed) -> Fixed

sinh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::sinh

fn sinh(self: Fixed) -> Fixed

sqrt

Fully qualified path: cubit::f128::types::fixed::FixedImpl::sqrt

fn sqrt(self: Fixed) -> Fixed

tan

Fully qualified path: cubit::f128::types::fixed::FixedImpl::tan

fn tan(self: Fixed) -> Fixed

tan_fast

Fully qualified path: cubit::f128::types::fixed::FixedImpl::tan_fast

fn tan_fast(self: Fixed) -> Fixed

tanh

Fully qualified path: cubit::f128::types::fixed::FixedImpl::tanh

fn tanh(self: Fixed) -> Fixed

Fixed128TryIntoFixed64

Fully qualified path: cubit::f128::types::fixed::Fixed128TryIntoFixed64

impl Fixed128TryIntoFixed64 of TryInto<Fixed, Fixed>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::Fixed128TryIntoFixed64::try_into

fn try_into(self: Fixed) -> Option<Fixed>

FixedPrint

Fully qualified path: cubit::f128::types::fixed::FixedPrint

impl FixedPrint of PrintTrait<Fixed>;

Impl functions

print

Fully qualified path: cubit::f128::types::fixed::FixedPrint::print

fn print(self: Fixed)

FixedInto

Fully qualified path: cubit::f128::types::fixed::FixedInto

impl FixedInto of Into<Fixed, felt252>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::FixedInto::into

fn into(self: Fixed) -> felt252

FixedTryIntoU128

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU128

impl FixedTryIntoU128 of TryInto<Fixed, u128>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU128::try_into

fn try_into(self: Fixed) -> Option<u128>

FixedTryIntoU64

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU64

impl FixedTryIntoU64 of TryInto<Fixed, u64>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU64::try_into

fn try_into(self: Fixed) -> Option<u64>

FixedTryIntoU32

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU32

impl FixedTryIntoU32 of TryInto<Fixed, u32>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU32::try_into

fn try_into(self: Fixed) -> Option<u32>

FixedTryIntoU16

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU16

impl FixedTryIntoU16 of TryInto<Fixed, u16>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU16::try_into

fn try_into(self: Fixed) -> Option<u16>

FixedTryIntoU8

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU8

impl FixedTryIntoU8 of TryInto<Fixed, u8>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::FixedTryIntoU8::try_into

fn try_into(self: Fixed) -> Option<u8>

U8IntoFixed

Fully qualified path: cubit::f128::types::fixed::U8IntoFixed

impl U8IntoFixed of Into<u8, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::U8IntoFixed::into

fn into(self: u8) -> Fixed

U16IntoFixed

Fully qualified path: cubit::f128::types::fixed::U16IntoFixed

impl U16IntoFixed of Into<u16, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::U16IntoFixed::into

fn into(self: u16) -> Fixed

U32IntoFixed

Fully qualified path: cubit::f128::types::fixed::U32IntoFixed

impl U32IntoFixed of Into<u32, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::U32IntoFixed::into

fn into(self: u32) -> Fixed

U64IntoFixed

Fully qualified path: cubit::f128::types::fixed::U64IntoFixed

impl U64IntoFixed of Into<u64, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::U64IntoFixed::into

fn into(self: u64) -> Fixed

U128IntoFixed

Fully qualified path: cubit::f128::types::fixed::U128IntoFixed

impl U128IntoFixed of Into<u128, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::U128IntoFixed::into

fn into(self: u128) -> Fixed

U256TryIntoFixed

Fully qualified path: cubit::f128::types::fixed::U256TryIntoFixed

impl U256TryIntoFixed of TryInto<u256, Fixed>;

Impl functions

try_into

Fully qualified path: cubit::f128::types::fixed::U256TryIntoFixed::try_into

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

I8IntoFixed

Fully qualified path: cubit::f128::types::fixed::I8IntoFixed

impl I8IntoFixed of Into<i8, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::I8IntoFixed::into

fn into(self: i8) -> Fixed

I16IntoFixed

Fully qualified path: cubit::f128::types::fixed::I16IntoFixed

impl I16IntoFixed of Into<i16, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::I16IntoFixed::into

fn into(self: i16) -> Fixed

I32IntoFixed

Fully qualified path: cubit::f128::types::fixed::I32IntoFixed

impl I32IntoFixed of Into<i32, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::I32IntoFixed::into

fn into(self: i32) -> Fixed

I64IntoFixed

Fully qualified path: cubit::f128::types::fixed::I64IntoFixed

impl I64IntoFixed of Into<i64, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::I64IntoFixed::into

fn into(self: i64) -> Fixed

I128IntoFixed

Fully qualified path: cubit::f128::types::fixed::I128IntoFixed

impl I128IntoFixed of Into<i128, Fixed>;

Impl functions

into

Fully qualified path: cubit::f128::types::fixed::I128IntoFixed::into

fn into(self: i128) -> Fixed

FixedPartialEq

Fully qualified path: cubit::f128::types::fixed::FixedPartialEq

impl FixedPartialEq of PartialEq<Fixed>;

Impl functions

eq

Fully qualified path: cubit::f128::types::fixed::FixedPartialEq::eq

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

ne

Fully qualified path: cubit::f128::types::fixed::FixedPartialEq::ne

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

FixedAdd

Fully qualified path: cubit::f128::types::fixed::FixedAdd

impl FixedAdd of Add<Fixed>;

Impl functions

add

Fully qualified path: cubit::f128::types::fixed::FixedAdd::add

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

FixedAddEq

Fully qualified path: cubit::f128::types::fixed::FixedAddEq

impl FixedAddEq of AddEq<Fixed>;

Impl functions

add_eq

Fully qualified path: cubit::f128::types::fixed::FixedAddEq::add_eq

fn add_eq(ref self: Fixed, other: Fixed)

FixedSub

Fully qualified path: cubit::f128::types::fixed::FixedSub

impl FixedSub of Sub<Fixed>;

Impl functions

sub

Fully qualified path: cubit::f128::types::fixed::FixedSub::sub

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

FixedSubEq

Fully qualified path: cubit::f128::types::fixed::FixedSubEq

impl FixedSubEq of SubEq<Fixed>;

Impl functions

sub_eq

Fully qualified path: cubit::f128::types::fixed::FixedSubEq::sub_eq

fn sub_eq(ref self: Fixed, other: Fixed)

FixedMul

Fully qualified path: cubit::f128::types::fixed::FixedMul

impl FixedMul of Mul<Fixed>;

Impl functions

mul

Fully qualified path: cubit::f128::types::fixed::FixedMul::mul

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

FixedMulEq

Fully qualified path: cubit::f128::types::fixed::FixedMulEq

impl FixedMulEq of MulEq<Fixed>;

Impl functions

mul_eq

Fully qualified path: cubit::f128::types::fixed::FixedMulEq::mul_eq

fn mul_eq(ref self: Fixed, other: Fixed)

FixedDiv

Fully qualified path: cubit::f128::types::fixed::FixedDiv

impl FixedDiv of Div<Fixed>;

Impl functions

div

Fully qualified path: cubit::f128::types::fixed::FixedDiv::div

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

FixedDivEq

Fully qualified path: cubit::f128::types::fixed::FixedDivEq

impl FixedDivEq of DivEq<Fixed>;

Impl functions

div_eq

Fully qualified path: cubit::f128::types::fixed::FixedDivEq::div_eq

fn div_eq(ref self: Fixed, other: Fixed)

FixedPartialOrd

Fully qualified path: cubit::f128::types::fixed::FixedPartialOrd

impl FixedPartialOrd of PartialOrd<Fixed>;

Impl functions

ge

Fully qualified path: cubit::f128::types::fixed::FixedPartialOrd::ge

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

gt

Fully qualified path: cubit::f128::types::fixed::FixedPartialOrd::gt

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

le

Fully qualified path: cubit::f128::types::fixed::FixedPartialOrd::le

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

lt

Fully qualified path: cubit::f128::types::fixed::FixedPartialOrd::lt

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

FixedNeg

Fully qualified path: cubit::f128::types::fixed::FixedNeg

impl FixedNeg of Neg<Fixed>;

Impl functions

neg

Fully qualified path: cubit::f128::types::fixed::FixedNeg::neg

fn neg(a: Fixed) -> Fixed

FixedRem

Fully qualified path: cubit::f128::types::fixed::FixedRem

impl FixedRem of Rem<Fixed>;

Impl functions

rem

Fully qualified path: cubit::f128::types::fixed::FixedRem::rem

fn rem(lhs: Fixed, rhs: Fixed) -> Fixed

PackFixed

Fully qualified path: cubit::f128::types::fixed::PackFixed

impl PackFixed of StorePacking<Fixed, felt252>;

Impl functions

pack

Fully qualified path: cubit::f128::types::fixed::PackFixed::pack

fn pack(value: Fixed) -> felt252

unpack

Fully qualified path: cubit::f128::types::fixed::PackFixed::unpack

fn unpack(value: felt252) -> Fixed

FixedZero

Fully qualified path: cubit::f128::types::fixed::FixedZero

impl FixedZero of Zero<Fixed>;

Impl functions

zero

Fully qualified path: cubit::f128::types::fixed::FixedZero::zero

fn zero() -> Fixed

is_zero

Fully qualified path: cubit::f128::types::fixed::FixedZero::is_zero

fn is_zero(self: @Fixed) -> bool

is_non_zero

Fully qualified path: cubit::f128::types::fixed::FixedZero::is_non_zero

fn is_non_zero(self: @Fixed) -> bool

FixedOne

Fully qualified path: cubit::f128::types::fixed::FixedOne

impl FixedOne of One<Fixed>;

Impl functions

one

Fully qualified path: cubit::f128::types::fixed::FixedOne::one

fn one() -> Fixed

is_one

Fully qualified path: cubit::f128::types::fixed::FixedOne::is_one

fn is_one(self: @Fixed) -> bool

is_non_one

Fully qualified path: cubit::f128::types::fixed::FixedOne::is_non_one

fn is_non_one(self: @Fixed) -> bool

FixedCopy

Fully qualified path: cubit::f128::types::fixed::FixedCopy

impl FixedCopy of Copy<Fixed>;

FixedDrop

Fully qualified path: cubit::f128::types::fixed::FixedDrop

impl FixedDrop of Drop<Fixed>;

FixedSerde

Fully qualified path: cubit::f128::types::fixed::FixedSerde

impl FixedSerde of Serde<Fixed>;

Impl functions

serialize

Fully qualified path: cubit::f128::types::fixed::FixedSerde::serialize

fn serialize(self: @Fixed, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f128::types::fixed::FixedSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Fixed>

vec2

Fully qualified path: cubit::f128::types::vec2

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec2	—

Traits


Vec2Trait	—

Impls


Vec2Impl	—
Vec2Print	—
Vec2Add	—
Vec2Div	—
Vec2Mul	—
Vec2Rem	—
Vec2Sub	—
Vec2Copy	—
Vec2Drop	—
Vec2Serde	—
Vec2Store	—

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f128::types::vec2::abs

fn abs(a: Vec2) -> Vec2

add

Fully qualified path: cubit::f128::types::vec2::add

fn add(a: Vec2, b: Vec2) -> Vec2

cross

Fully qualified path: cubit::f128::types::vec2::cross

fn cross(a: Vec2, b: Vec2) -> Fixed

div

Fully qualified path: cubit::f128::types::vec2::div

fn div(a: Vec2, b: Vec2) -> Vec2

dot

Fully qualified path: cubit::f128::types::vec2::dot

fn dot(a: Vec2, b: Vec2) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec2::floor

fn floor(a: Vec2) -> Vec2

mul

Fully qualified path: cubit::f128::types::vec2::mul

fn mul(a: Vec2, b: Vec2) -> Vec2

norm

Fully qualified path: cubit::f128::types::vec2::norm

fn norm(a: Vec2) -> Fixed

rem

Fully qualified path: cubit::f128::types::vec2::rem

fn rem(a: Vec2, b: Vec2) -> Vec2

sub

Fully qualified path: cubit::f128::types::vec2::sub

fn sub(a: Vec2, b: Vec2) -> Vec2

Structs


Vec2	—

Vec2

Fully qualified path: cubit::f128::types::vec2::Vec2

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec2 {
    x: Fixed,
    y: Fixed,
}

Members

x

Fully qualified path: cubit::f128::types::vec2::Vec2::x

x: Fixed

y

Fully qualified path: cubit::f128::types::vec2::Vec2::y

y: Fixed

Traits


Vec2Trait	—

Vec2Trait

Fully qualified path: cubit::f128::types::vec2::Vec2Trait

trait Vec2Trait

Trait functions

new

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::new

fn new(x: Fixed, y: Fixed) -> Vec2

splat

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::splat

fn splat(v: Fixed) -> Vec2

abs

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::abs

fn abs(self: Vec2) -> Vec2

cross

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::cross

fn cross(self: Vec2, rhs: Vec2) -> Fixed

dot

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::dot

fn dot(self: Vec2, rhs: Vec2) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::floor

fn floor(self: Vec2) -> Vec2

norm

Fully qualified path: cubit::f128::types::vec2::Vec2Trait::norm

fn norm(self: Vec2) -> Fixed

Impls


Vec2Impl	—
Vec2Print	—
Vec2Add	—
Vec2Div	—
Vec2Mul	—
Vec2Rem	—
Vec2Sub	—
Vec2Copy	—
Vec2Drop	—
Vec2Serde	—
Vec2Store	—

Vec2Impl

Fully qualified path: cubit::f128::types::vec2::Vec2Impl

impl Vec2Impl of Vec2Trait;

Impl functions

new

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::new

fn new(x: Fixed, y: Fixed) -> Vec2

splat

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::splat

fn splat(v: Fixed) -> Vec2

abs

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::abs

fn abs(self: Vec2) -> Vec2

cross

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::cross

fn cross(self: Vec2, rhs: Vec2) -> Fixed

dot

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::dot

fn dot(self: Vec2, rhs: Vec2) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::floor

fn floor(self: Vec2) -> Vec2

norm

Fully qualified path: cubit::f128::types::vec2::Vec2Impl::norm

fn norm(self: Vec2) -> Fixed

Vec2Print

Fully qualified path: cubit::f128::types::vec2::Vec2Print

impl Vec2Print of PrintTrait<Vec2>;

Impl functions

print

Fully qualified path: cubit::f128::types::vec2::Vec2Print::print

fn print(self: Vec2)

Vec2Add

Fully qualified path: cubit::f128::types::vec2::Vec2Add

impl Vec2Add of Add<Vec2>;

Impl functions

add

Fully qualified path: cubit::f128::types::vec2::Vec2Add::add

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

Vec2Div

Fully qualified path: cubit::f128::types::vec2::Vec2Div

impl Vec2Div of Div<Vec2>;

Impl functions

div

Fully qualified path: cubit::f128::types::vec2::Vec2Div::div

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

Vec2Mul

Fully qualified path: cubit::f128::types::vec2::Vec2Mul

impl Vec2Mul of Mul<Vec2>;

Impl functions

mul

Fully qualified path: cubit::f128::types::vec2::Vec2Mul::mul

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

Vec2Rem

Fully qualified path: cubit::f128::types::vec2::Vec2Rem

impl Vec2Rem of Rem<Vec2>;

Impl functions

rem

Fully qualified path: cubit::f128::types::vec2::Vec2Rem::rem

fn rem(lhs: Vec2, rhs: Vec2) -> Vec2

Vec2Sub

Fully qualified path: cubit::f128::types::vec2::Vec2Sub

impl Vec2Sub of Sub<Vec2>;

Impl functions

sub

Fully qualified path: cubit::f128::types::vec2::Vec2Sub::sub

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

Vec2Copy

Fully qualified path: cubit::f128::types::vec2::Vec2Copy

impl Vec2Copy of Copy<Vec2>;

Vec2Drop

Fully qualified path: cubit::f128::types::vec2::Vec2Drop

impl Vec2Drop of Drop<Vec2>;

Vec2Serde

Fully qualified path: cubit::f128::types::vec2::Vec2Serde

impl Vec2Serde of Serde<Vec2>;

Impl functions

serialize

Fully qualified path: cubit::f128::types::vec2::Vec2Serde::serialize

fn serialize(self: @Vec2, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f128::types::vec2::Vec2Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec2>

Vec2Store

Fully qualified path: cubit::f128::types::vec2::Vec2Store

impl Vec2Store of Store<Vec2>;

Impl functions

read

Fully qualified path: cubit::f128::types::vec2::Vec2Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec2, Array<felt252>>

write

Fully qualified path: cubit::f128::types::vec2::Vec2Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec2) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f128::types::vec2::Vec2Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec2, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f128::types::vec2::Vec2Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec2,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f128::types::vec2::Vec2Store::size

fn size() -> u8

vec3

Fully qualified path: cubit::f128::types::vec3

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec3	—

Traits


Vec3Trait	—

Impls


Vec3Impl	—
Vec3Print	—
Vec3Add	—
Vec3Div	—
Vec3Mul	—
Vec3Rem	—
Vec3Sub	—
Vec3Copy	—
Vec3Drop	—
Vec3Serde	—
Vec3Store	—

Free functions


abs	—
add	—
cross	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f128::types::vec3::abs

fn abs(a: Vec3) -> Vec3

add

Fully qualified path: cubit::f128::types::vec3::add

fn add(a: Vec3, b: Vec3) -> Vec3

cross

Fully qualified path: cubit::f128::types::vec3::cross

fn cross(a: Vec3, b: Vec3) -> Vec3

div

Fully qualified path: cubit::f128::types::vec3::div

fn div(a: Vec3, b: Vec3) -> Vec3

dot

Fully qualified path: cubit::f128::types::vec3::dot

fn dot(a: Vec3, b: Vec3) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec3::floor

fn floor(a: Vec3) -> Vec3

mul

Fully qualified path: cubit::f128::types::vec3::mul

fn mul(a: Vec3, b: Vec3) -> Vec3

norm

Fully qualified path: cubit::f128::types::vec3::norm

fn norm(a: Vec3) -> Fixed

rem

Fully qualified path: cubit::f128::types::vec3::rem

fn rem(a: Vec3, b: Vec3) -> Vec3

sub

Fully qualified path: cubit::f128::types::vec3::sub

fn sub(a: Vec3, b: Vec3) -> Vec3

Structs


Vec3	—

Vec3

Fully qualified path: cubit::f128::types::vec3::Vec3

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec3 {
    x: Fixed,
    y: Fixed,
    z: Fixed,
}

Members

x

Fully qualified path: cubit::f128::types::vec3::Vec3::x

x: Fixed

y

Fully qualified path: cubit::f128::types::vec3::Vec3::y

y: Fixed

z

Fully qualified path: cubit::f128::types::vec3::Vec3::z

z: Fixed

Traits


Vec3Trait	—

Vec3Trait

Fully qualified path: cubit::f128::types::vec3::Vec3Trait

trait Vec3Trait

Trait functions

new

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::new

fn new(x: Fixed, y: Fixed, z: Fixed) -> Vec3

splat

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::splat

fn splat(v: Fixed) -> Vec3

abs

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::abs

fn abs(self: Vec3) -> Vec3

cross

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::cross

fn cross(self: Vec3, rhs: Vec3) -> Vec3

dot

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::dot

fn dot(self: Vec3, rhs: Vec3) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::floor

fn floor(self: Vec3) -> Vec3

norm

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::norm

fn norm(self: Vec3) -> Fixed

add

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::add

fn add(self: Vec3, scalar: Fixed) -> Vec3

sub

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::sub

fn sub(self: Vec3, scalar: Fixed) -> Vec3

mul

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::mul

fn mul(self: Vec3, scalar: Fixed) -> Vec3

div

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::div

fn div(self: Vec3, scalar: Fixed) -> Vec3

rem

Fully qualified path: cubit::f128::types::vec3::Vec3Trait::rem

fn rem(self: Vec3, scalar: Fixed) -> Vec3

Impls


Vec3Impl	—
Vec3Print	—
Vec3Add	—
Vec3Div	—
Vec3Mul	—
Vec3Rem	—
Vec3Sub	—
Vec3Copy	—
Vec3Drop	—
Vec3Serde	—
Vec3Store	—

Vec3Impl

Fully qualified path: cubit::f128::types::vec3::Vec3Impl

impl Vec3Impl of Vec3Trait;

Impl functions

new

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::new

fn new(x: Fixed, y: Fixed, z: Fixed) -> Vec3

splat

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::splat

fn splat(v: Fixed) -> Vec3

abs

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::abs

fn abs(self: Vec3) -> Vec3

cross

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::cross

fn cross(self: Vec3, rhs: Vec3) -> Vec3

dot

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::dot

fn dot(self: Vec3, rhs: Vec3) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::floor

fn floor(self: Vec3) -> Vec3

norm

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::norm

fn norm(self: Vec3) -> Fixed

add

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::add

fn add(self: Vec3, scalar: Fixed) -> Vec3

sub

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::sub

fn sub(self: Vec3, scalar: Fixed) -> Vec3

mul

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::mul

fn mul(self: Vec3, scalar: Fixed) -> Vec3

div

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::div

fn div(self: Vec3, scalar: Fixed) -> Vec3

rem

Fully qualified path: cubit::f128::types::vec3::Vec3Impl::rem

fn rem(self: Vec3, scalar: Fixed) -> Vec3

Vec3Print

Fully qualified path: cubit::f128::types::vec3::Vec3Print

impl Vec3Print of PrintTrait<Vec3>;

Impl functions

print

Fully qualified path: cubit::f128::types::vec3::Vec3Print::print

fn print(self: Vec3)

Vec3Add

Fully qualified path: cubit::f128::types::vec3::Vec3Add

impl Vec3Add of Add<Vec3>;

Impl functions

add

Fully qualified path: cubit::f128::types::vec3::Vec3Add::add

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

Vec3Div

Fully qualified path: cubit::f128::types::vec3::Vec3Div

impl Vec3Div of Div<Vec3>;

Impl functions

div

Fully qualified path: cubit::f128::types::vec3::Vec3Div::div

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

Vec3Mul

Fully qualified path: cubit::f128::types::vec3::Vec3Mul

impl Vec3Mul of Mul<Vec3>;

Impl functions

mul

Fully qualified path: cubit::f128::types::vec3::Vec3Mul::mul

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

Vec3Rem

Fully qualified path: cubit::f128::types::vec3::Vec3Rem

impl Vec3Rem of Rem<Vec3>;

Impl functions

rem

Fully qualified path: cubit::f128::types::vec3::Vec3Rem::rem

fn rem(lhs: Vec3, rhs: Vec3) -> Vec3

Vec3Sub

Fully qualified path: cubit::f128::types::vec3::Vec3Sub

impl Vec3Sub of Sub<Vec3>;

Impl functions

sub

Fully qualified path: cubit::f128::types::vec3::Vec3Sub::sub

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

Vec3Copy

Fully qualified path: cubit::f128::types::vec3::Vec3Copy

impl Vec3Copy of Copy<Vec3>;

Vec3Drop

Fully qualified path: cubit::f128::types::vec3::Vec3Drop

impl Vec3Drop of Drop<Vec3>;

Vec3Serde

Fully qualified path: cubit::f128::types::vec3::Vec3Serde

impl Vec3Serde of Serde<Vec3>;

Impl functions

serialize

Fully qualified path: cubit::f128::types::vec3::Vec3Serde::serialize

fn serialize(self: @Vec3, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f128::types::vec3::Vec3Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec3>

Vec3Store

Fully qualified path: cubit::f128::types::vec3::Vec3Store

impl Vec3Store of Store<Vec3>;

Impl functions

read

Fully qualified path: cubit::f128::types::vec3::Vec3Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec3, Array<felt252>>

write

Fully qualified path: cubit::f128::types::vec3::Vec3Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec3) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f128::types::vec3::Vec3Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec3, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f128::types::vec3::Vec3Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec3,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f128::types::vec3::Vec3Store::size

fn size() -> u8

vec4

Fully qualified path: cubit::f128::types::vec4

Free functions


abs	—
add	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

Structs


Vec4	—

Traits


Vec4Trait	—

Impls


Vec4Impl	—
Vec4Print	—
Vec4Add	—
Vec4Div	—
Vec4Mul	—
Vec4Rem	—
Vec4Sub	—
Vec4Copy	—
Vec4Drop	—
Vec4Serde	—
Vec4Store	—

Free functions


abs	—
add	—
div	—
dot	—
floor	—
mul	—
norm	—
rem	—
sub	—

abs

Fully qualified path: cubit::f128::types::vec4::abs

fn abs(a: Vec4) -> Vec4

add

Fully qualified path: cubit::f128::types::vec4::add

fn add(a: Vec4, b: Vec4) -> Vec4

div

Fully qualified path: cubit::f128::types::vec4::div

fn div(a: Vec4, b: Vec4) -> Vec4

dot

Fully qualified path: cubit::f128::types::vec4::dot

fn dot(a: Vec4, b: Vec4) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec4::floor

fn floor(a: Vec4) -> Vec4

mul

Fully qualified path: cubit::f128::types::vec4::mul

fn mul(a: Vec4, b: Vec4) -> Vec4

norm

Fully qualified path: cubit::f128::types::vec4::norm

fn norm(a: Vec4) -> Fixed

rem

Fully qualified path: cubit::f128::types::vec4::rem

fn rem(a: Vec4, b: Vec4) -> Vec4

sub

Fully qualified path: cubit::f128::types::vec4::sub

fn sub(a: Vec4, b: Vec4) -> Vec4

Structs


Vec4	—

Vec4

Fully qualified path: cubit::f128::types::vec4::Vec4

#[derive(Copy, Drop, Serde, starknet::Store)]
struct Vec4 {
    x: Fixed,
    y: Fixed,
    z: Fixed,
    w: Fixed,
}

Members

x

Fully qualified path: cubit::f128::types::vec4::Vec4::x

x: Fixed

y

Fully qualified path: cubit::f128::types::vec4::Vec4::y

y: Fixed

z

Fully qualified path: cubit::f128::types::vec4::Vec4::z

z: Fixed

w

Fully qualified path: cubit::f128::types::vec4::Vec4::w

w: Fixed

Traits


Vec4Trait	—

Vec4Trait

Fully qualified path: cubit::f128::types::vec4::Vec4Trait

trait Vec4Trait

Trait functions

new

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::new

fn new(x: Fixed, y: Fixed, z: Fixed, w: Fixed) -> Vec4

splat

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::splat

fn splat(v: Fixed) -> Vec4

abs

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::abs

fn abs(self: Vec4) -> Vec4

dot

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::dot

fn dot(self: Vec4, rhs: Vec4) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::floor

fn floor(self: Vec4) -> Vec4

norm

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::norm

fn norm(self: Vec4) -> Fixed

add

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::add

fn add(self: Vec4, scalar: Fixed) -> Vec4

sub

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::sub

fn sub(self: Vec4, scalar: Fixed) -> Vec4

mul

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::mul

fn mul(self: Vec4, scalar: Fixed) -> Vec4

div

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::div

fn div(self: Vec4, scalar: Fixed) -> Vec4

rem

Fully qualified path: cubit::f128::types::vec4::Vec4Trait::rem

fn rem(self: Vec4, scalar: Fixed) -> Vec4

Impls


Vec4Impl	—
Vec4Print	—
Vec4Add	—
Vec4Div	—
Vec4Mul	—
Vec4Rem	—
Vec4Sub	—
Vec4Copy	—
Vec4Drop	—
Vec4Serde	—
Vec4Store	—

Vec4Impl

Fully qualified path: cubit::f128::types::vec4::Vec4Impl

impl Vec4Impl of Vec4Trait;

Impl functions

new

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::new

fn new(x: Fixed, y: Fixed, z: Fixed, w: Fixed) -> Vec4

splat

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::splat

fn splat(v: Fixed) -> Vec4

abs

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::abs

fn abs(self: Vec4) -> Vec4

dot

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::dot

fn dot(self: Vec4, rhs: Vec4) -> Fixed

floor

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::floor

fn floor(self: Vec4) -> Vec4

norm

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::norm

fn norm(self: Vec4) -> Fixed

add

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::add

fn add(self: Vec4, scalar: Fixed) -> Vec4

sub

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::sub

fn sub(self: Vec4, scalar: Fixed) -> Vec4

mul

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::mul

fn mul(self: Vec4, scalar: Fixed) -> Vec4

div

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::div

fn div(self: Vec4, scalar: Fixed) -> Vec4

rem

Fully qualified path: cubit::f128::types::vec4::Vec4Impl::rem

fn rem(self: Vec4, scalar: Fixed) -> Vec4

Vec4Print

Fully qualified path: cubit::f128::types::vec4::Vec4Print

impl Vec4Print of PrintTrait<Vec4>;

Impl functions

print

Fully qualified path: cubit::f128::types::vec4::Vec4Print::print

fn print(self: Vec4)

Vec4Add

Fully qualified path: cubit::f128::types::vec4::Vec4Add

impl Vec4Add of Add<Vec4>;

Impl functions

add

Fully qualified path: cubit::f128::types::vec4::Vec4Add::add

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

Vec4Div

Fully qualified path: cubit::f128::types::vec4::Vec4Div

impl Vec4Div of Div<Vec4>;

Impl functions

div

Fully qualified path: cubit::f128::types::vec4::Vec4Div::div

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

Vec4Mul

Fully qualified path: cubit::f128::types::vec4::Vec4Mul

impl Vec4Mul of Mul<Vec4>;

Impl functions

mul

Fully qualified path: cubit::f128::types::vec4::Vec4Mul::mul

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

Vec4Rem

Fully qualified path: cubit::f128::types::vec4::Vec4Rem

impl Vec4Rem of Rem<Vec4>;

Impl functions

rem

Fully qualified path: cubit::f128::types::vec4::Vec4Rem::rem

fn rem(lhs: Vec4, rhs: Vec4) -> Vec4

Vec4Sub

Fully qualified path: cubit::f128::types::vec4::Vec4Sub

impl Vec4Sub of Sub<Vec4>;

Impl functions

sub

Fully qualified path: cubit::f128::types::vec4::Vec4Sub::sub

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

Vec4Copy

Fully qualified path: cubit::f128::types::vec4::Vec4Copy

impl Vec4Copy of Copy<Vec4>;

Vec4Drop

Fully qualified path: cubit::f128::types::vec4::Vec4Drop

impl Vec4Drop of Drop<Vec4>;

Vec4Serde

Fully qualified path: cubit::f128::types::vec4::Vec4Serde

impl Vec4Serde of Serde<Vec4>;

Impl functions

serialize

Fully qualified path: cubit::f128::types::vec4::Vec4Serde::serialize

fn serialize(self: @Vec4, ref output: Array<felt252>)

deserialize

Fully qualified path: cubit::f128::types::vec4::Vec4Serde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Vec4>

Vec4Store

Fully qualified path: cubit::f128::types::vec4::Vec4Store

impl Vec4Store of Store<Vec4>;

Impl functions

read

Fully qualified path: cubit::f128::types::vec4::Vec4Store::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Vec4, Array<felt252>>

write

Fully qualified path: cubit::f128::types::vec4::Vec4Store::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Vec4) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: cubit::f128::types::vec4::Vec4Store::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Vec4, Array<felt252>>

write_at_offset

Fully qualified path: cubit::f128::types::vec4::Vec4Store::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Vec4,
) -> Result<(), Array<felt252>>

size

Fully qualified path: cubit::f128::types::vec4::Vec4Store::size

fn size() -> u8

utils

Fully qualified path: cubit::utils

Constants


HALF_PRIME	—

Free functions


felt_sign	—
felt_abs	—

Constants


HALF_PRIME	—

HALF_PRIME

Fully qualified path: cubit::utils::HALF_PRIME

const HALF_PRIME: felt252 =
    1809251394333065606848661391547535052811553607665798349986546028067936010240;

Free functions


felt_sign	—
felt_abs	—

felt_sign

Fully qualified path: cubit::utils::felt_sign

fn felt_sign(a: felt252) -> bool

felt_abs

Fully qualified path: cubit::utils::felt_abs

fn felt_abs(a: felt252) -> felt252

Keyboard shortcuts

cubit - Cairo