Struct fpn::base::FPN

pub struct FPN<I, F> { /* fields omitted */ }

I: Interge type as storage, F: number of bits for fractions.

Implementations

impl<F> FPN<i8, F> where
    F: Unsigned, 

pub fn min() -> Self

pub fn max() -> Self

pub fn cos(&self) -> Self

cos is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05.

pub fn sin(&self) -> Self

sin is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small which is around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05. In implementation, sin(angle) = cos(angle - pi/2).

pub fn tan(&self) -> Self

tan is calulated with prepare list of tan values for angles from 0 to pi/2. The difference to the value of the float is normally pretty small. However for values bigger than 1 or smaller than -1, the curve starts going steep, and the difference at this case could be bigger and non-negligible.

pub fn pi() -> Self

pub fn pi_square() -> Self

pub fn pi_double() -> Self

pub fn pi_half() -> Self

pub fn pi_quad() -> Self

pub fn load(v: i8) -> Self

Load raw value without shifting

pub fn add_raw(&mut self, v: i8)

Add values to the raw storage whith shifting

pub fn mul_raw(&mut self, v: i8)

Mul values to the raw storage whith shifting

pub fn sub_raw(&mut self, v: i8)

Sub values to the raw storage whith shifting

pub fn div_raw(&mut self, v: i8)

Div values to the raw storage whith shifting

pub fn int(&self) -> i8

Convert to T, which will remove the fraction part.

pub fn abs(&self) -> Self

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

pub fn squared(self) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn eps() -> f32

pub fn get_eps(&self) -> f32

pub fn signum(&self) -> i8

pub fn is_positive(&self) -> bool

pub fn is_negative(&self) -> bool

pub fn frac(&self) -> f32

pub fn new<T: Into<f64>>(v: T) -> Self

Create new FPN from a float value

pub fn raw(&self) -> i8

pub fn with(v: i8) -> Self

Convert from T

pub fn to_f32(&self) -> f32

pub fn from_f32(v: f32) -> Self

pub fn to_f64(&self) -> f64

pub fn from_f64(v: f64) -> Self

pub fn to_i64(&self) -> i64

pub fn from_i64(v: i64) -> Self

pub fn pow(&self, v: usize) -> Self

pub fn pow_assign(&mut self, v: usize)

impl<F> FPN<i16, F> where
    F: Unsigned, 

pub fn min() -> Self

pub fn max() -> Self

pub fn cos(&self) -> Self

cos is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05.

pub fn sin(&self) -> Self

sin is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small which is around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05. In implementation, sin(angle) = cos(angle - pi/2).

pub fn tan(&self) -> Self

tan is calulated with prepare list of tan values for angles from 0 to pi/2. The difference to the value of the float is normally pretty small. However for values bigger than 1 or smaller than -1, the curve starts going steep, and the difference at this case could be bigger and non-negligible.

pub fn pi() -> Self

pub fn pi_square() -> Self

pub fn pi_double() -> Self

pub fn pi_half() -> Self

pub fn pi_quad() -> Self

pub fn load(v: i16) -> Self

Load raw value without shifting

pub fn add_raw(&mut self, v: i16)

Add values to the raw storage whith shifting

pub fn mul_raw(&mut self, v: i16)

Mul values to the raw storage whith shifting

pub fn sub_raw(&mut self, v: i16)

Sub values to the raw storage whith shifting

pub fn div_raw(&mut self, v: i16)

Div values to the raw storage whith shifting

pub fn int(&self) -> i16

Convert to T, which will remove the fraction part.

pub fn abs(&self) -> Self

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

pub fn squared(self) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn eps() -> f32

pub fn get_eps(&self) -> f32

pub fn signum(&self) -> i16

pub fn is_positive(&self) -> bool

pub fn is_negative(&self) -> bool

pub fn frac(&self) -> f32

pub fn new<T: Into<f64>>(v: T) -> Self

Create new FPN from a float value

pub fn raw(&self) -> i16

pub fn with(v: i16) -> Self

Convert from T

pub fn to_f32(&self) -> f32

pub fn from_f32(v: f32) -> Self

pub fn to_f64(&self) -> f64

pub fn from_f64(v: f64) -> Self

pub fn to_i64(&self) -> i64

pub fn from_i64(v: i64) -> Self

pub fn pow(&self, v: usize) -> Self

pub fn pow_assign(&mut self, v: usize)

impl<F> FPN<i32, F> where
    F: Unsigned, 

pub fn min() -> Self

pub fn max() -> Self

pub fn cos(&self) -> Self

cos is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05.

pub fn sin(&self) -> Self

sin is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small which is around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05. In implementation, sin(angle) = cos(angle - pi/2).

pub fn tan(&self) -> Self

tan is calulated with prepare list of tan values for angles from 0 to pi/2. The difference to the value of the float is normally pretty small. However for values bigger than 1 or smaller than -1, the curve starts going steep, and the difference at this case could be bigger and non-negligible.

pub fn pi() -> Self

pub fn pi_square() -> Self

pub fn pi_double() -> Self

pub fn pi_half() -> Self

pub fn pi_quad() -> Self

pub fn load(v: i32) -> Self

Load raw value without shifting

pub fn add_raw(&mut self, v: i32)

Add values to the raw storage whith shifting

pub fn mul_raw(&mut self, v: i32)

Mul values to the raw storage whith shifting

pub fn sub_raw(&mut self, v: i32)

Sub values to the raw storage whith shifting

pub fn div_raw(&mut self, v: i32)

Div values to the raw storage whith shifting

pub fn int(&self) -> i32

Convert to T, which will remove the fraction part.

pub fn abs(&self) -> Self

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

pub fn squared(self) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn eps() -> f32

pub fn get_eps(&self) -> f32

pub fn signum(&self) -> i32

pub fn is_positive(&self) -> bool

pub fn is_negative(&self) -> bool

pub fn frac(&self) -> f32

pub fn new<T: Into<f64>>(v: T) -> Self

Create new FPN from a float value

pub fn raw(&self) -> i32

pub fn with(v: i32) -> Self

Convert from T

pub fn to_f32(&self) -> f32

pub fn from_f32(v: f32) -> Self

pub fn to_f64(&self) -> f64

pub fn from_f64(v: f64) -> Self

pub fn to_i64(&self) -> i64

pub fn from_i64(v: i64) -> Self

pub fn pow(&self, v: usize) -> Self

pub fn pow_assign(&mut self, v: usize)

impl<F> FPN<i64, F> where
    F: Unsigned, 

pub fn min() -> Self

pub fn max() -> Self

pub fn cos(&self) -> Self

cos is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05.

pub fn sin(&self) -> Self

sin is calculated with prepared list of cos and sin values for angle from 0 to pi/4. The difference to value of float normally should be pretty small which is around 0.0039, but it could be a bit big when curve goes steep, with this case, it's normally still below 0.05. In implementation, sin(angle) = cos(angle - pi/2).

pub fn tan(&self) -> Self

tan is calulated with prepare list of tan values for angles from 0 to pi/2. The difference to the value of the float is normally pretty small. However for values bigger than 1 or smaller than -1, the curve starts going steep, and the difference at this case could be bigger and non-negligible.

pub fn pi() -> Self

pub fn pi_square() -> Self

pub fn pi_double() -> Self

pub fn pi_half() -> Self

pub fn pi_quad() -> Self

pub fn load(v: i64) -> Self

Load raw value without shifting

pub fn add_raw(&mut self, v: i64)

Add values to the raw storage whith shifting

pub fn mul_raw(&mut self, v: i64)

Mul values to the raw storage whith shifting

pub fn sub_raw(&mut self, v: i64)

Sub values to the raw storage whith shifting

pub fn div_raw(&mut self, v: i64)

Div values to the raw storage whith shifting

pub fn int(&self) -> i64

Convert to T, which will remove the fraction part.

pub fn abs(&self) -> Self

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

pub fn squared(self) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn eps() -> f32

pub fn get_eps(&self) -> f32

pub fn signum(&self) -> i64

pub fn is_positive(&self) -> bool

pub fn is_negative(&self) -> bool

pub fn frac(&self) -> f32

pub fn new<T: Into<f64>>(v: T) -> Self

Create new FPN from a float value

pub fn raw(&self) -> i64

pub fn with(v: i64) -> Self

Convert from T

pub fn to_f32(&self) -> f32

pub fn from_f32(v: f32) -> Self

pub fn to_f64(&self) -> f64

pub fn from_f64(v: f64) -> Self

pub fn to_i64(&self) -> i64

pub fn from_i64(v: i64) -> Self

pub fn pow(&self, v: usize) -> Self

pub fn pow_assign(&mut self, v: usize)

Trait Implementations

impl<F> Add<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: Self) -> Self

Performs the + operation.

impl<F> Add<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: Self) -> Self

Performs the + operation.

impl<F> Add<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: Self) -> Self

Performs the + operation.

impl<F> Add<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: Self) -> Self

Performs the + operation.

impl<F> Add<i16> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: i16) -> Self

Performs the + operation.

impl<F> Add<i32> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: i32) -> Self

Performs the + operation.

impl<F> Add<i64> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: i64) -> Self

Performs the + operation.

impl<F> Add<i8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, v: i8) -> Self

Performs the + operation.

impl<F> AddAssign<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: Self)

Performs the += operation.

impl<F> AddAssign<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: Self)

Performs the += operation.

impl<F> AddAssign<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: Self)

Performs the += operation.

impl<F> AddAssign<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: Self)

Performs the += operation.

impl<F> AddAssign<i16> for FPN<i16, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: i16)

Performs the += operation.

impl<F> AddAssign<i32> for FPN<i32, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: i32)

Performs the += operation.

impl<F> AddAssign<i64> for FPN<i64, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: i64)

Performs the += operation.

impl<F> AddAssign<i8> for FPN<i8, F> where
    F: Unsigned, 

fn add_assign(&mut self, v: i8)

Performs the += operation.

impl<I, F> Clone for FPN<I, F> where
    I: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, F> Copy for FPN<I, F> where
    I: Copy, 

impl<F> Cross<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Cross<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

fn cross(&self, v: &Self) -> Self

impl<F> Debug for FPN<i8, F>

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

Formats the value using the given formatter.

impl<F> Debug for FPN<i16, F>

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

Formats the value using the given formatter.

impl<F> Debug for FPN<i32, F>

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

Formats the value using the given formatter.

impl<F> Debug for FPN<i64, F>

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

Formats the value using the given formatter.

impl<F> Display for FPN<i8, F> where
    F: Unsigned, 

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

Formats the value using the given formatter.

impl<F> Display for FPN<i16, F> where
    F: Unsigned, 

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

Formats the value using the given formatter.

impl<F> Display for FPN<i32, F> where
    F: Unsigned, 

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

Formats the value using the given formatter.

impl<F> Display for FPN<i64, F> where
    F: Unsigned, 

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

Formats the value using the given formatter.

impl<F> Div<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: Self) -> Self

Performs the / operation.

impl<F> Div<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i16, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i16, F>> for &'_ FVector2<i16, F> where
    F: Unsigned, 

type Output = FVector2<i16, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i16, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i16, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i16, F>> for &'_ FVector3<i16, F> where
    F: Unsigned, 

type Output = FVector3<i16, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i16, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: Self) -> Self

Performs the / operation.

impl<F> Div<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i32, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i32, F>> for &'_ FVector2<i32, F> where
    F: Unsigned, 

type Output = FVector2<i32, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i32, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i32, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i32, F>> for &'_ FVector3<i32, F> where
    F: Unsigned, 

type Output = FVector3<i32, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i32, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: Self) -> Self

Performs the / operation.

impl<F> Div<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i64, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i64, F>> for &'_ FVector2<i64, F> where
    F: Unsigned, 

type Output = FVector2<i64, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i64, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i64, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i64, F>> for &'_ FVector3<i64, F> where
    F: Unsigned, 

type Output = FVector3<i64, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i64, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: Self) -> Self

Performs the / operation.

impl<F> Div<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i8, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i8, F>> for &'_ FVector2<i8, F> where
    F: Unsigned, 

type Output = FVector2<i8, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i8, F>) -> Self::Output

Performs the / operation.

impl<F> Div<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: FPN<i8, F>) -> Self::Output

Performs the / operation.

impl<'_, F> Div<FPN<i8, F>> for &'_ FVector3<i8, F> where
    F: Unsigned, 

type Output = FVector3<i8, F>

The resulting type after applying the / operator.

fn div(self, v: FPN<i8, F>) -> Self::Output

Performs the / operation.

impl<F> Div<i16> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: i16) -> Self

Performs the / operation.

impl<F> Div<i32> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: i32) -> Self

Performs the / operation.

impl<F> Div<i64> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: i64) -> Self

Performs the / operation.

impl<F> Div<i8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, v: i8) -> Self

Performs the / operation.

impl<F> DivAssign<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: Self)

Performs the /= operation.

impl<F> DivAssign<FPN<i16, F>> for Vector2<FPN<i16, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i16, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i16, F>> for Vector3<FPN<i16, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i16, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: Self)

Performs the /= operation.

impl<F> DivAssign<FPN<i32, F>> for Vector2<FPN<i32, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i32, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i32, F>> for Vector3<FPN<i32, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i32, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: Self)

Performs the /= operation.

impl<F> DivAssign<FPN<i64, F>> for Vector2<FPN<i64, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i64, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i64, F>> for Vector3<FPN<i64, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i64, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: Self)

Performs the /= operation.

impl<F> DivAssign<FPN<i8, F>> for Vector2<FPN<i8, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i8, F>)

Performs the /= operation.

impl<F> DivAssign<FPN<i8, F>> for Vector3<FPN<i8, F>> where
    F: Unsigned, 

fn div_assign(&mut self, v: FPN<i8, F>)

Performs the /= operation.

impl<F> DivAssign<i16> for FPN<i16, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: i16)

Performs the /= operation.

impl<F> DivAssign<i32> for FPN<i32, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: i32)

Performs the /= operation.

impl<F> DivAssign<i64> for FPN<i64, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: i64)

Performs the /= operation.

impl<F> DivAssign<i8> for FPN<i8, F> where
    F: Unsigned, 

fn div_assign(&mut self, v: i8)

Performs the /= operation.

impl<F> Dot<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i16, F>

impl<F> Dot<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i16, F>

impl<F> Dot<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i32, F>

impl<F> Dot<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i32, F>

impl<F> Dot<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i64, F>

impl<F> Dot<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i64, F>

impl<F> Dot<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i8, F>

impl<F> Dot<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

fn dot(&self, v: &Self) -> FPN<i8, F>

impl<I, F> Eq for FPN<I, F> where
    I: Eq, 

impl<F> From<FPN<i16, F>> for f32 where
    F: Unsigned, 

fn from(fpn: FPN<i16, F>) -> f32

Performs the conversion.

impl<F> From<FPN<i16, F>> for f64 where
    F: Unsigned, 

fn from(fpn: FPN<i16, F>) -> f64

Performs the conversion.

impl<F> From<FPN<i32, F>> for f32 where
    F: Unsigned, 

fn from(fpn: FPN<i32, F>) -> f32

Performs the conversion.

impl<F> From<FPN<i32, F>> for f64 where
    F: Unsigned, 

fn from(fpn: FPN<i32, F>) -> f64

Performs the conversion.

impl<F> From<FPN<i64, F>> for f32 where
    F: Unsigned, 

fn from(fpn: FPN<i64, F>) -> f32

Performs the conversion.

impl<F> From<FPN<i64, F>> for f64 where
    F: Unsigned, 

fn from(fpn: FPN<i64, F>) -> f64

Performs the conversion.

impl<F> From<FPN<i8, F>> for f32 where
    F: Unsigned, 

fn from(fpn: FPN<i8, F>) -> f32

Performs the conversion.

impl<F> From<FPN<i8, F>> for f64 where
    F: Unsigned, 

fn from(fpn: FPN<i8, F>) -> f64

Performs the conversion.

impl<F> Mul<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: Self) -> Self

Performs the * operation.

impl<F> Mul<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i16, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i16, F>> for &'_ FVector2<i16, F> where
    F: Unsigned, 

type Output = FVector2<i16, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i16, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i16, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i16, F>> for &'_ FVector3<i16, F> where
    F: Unsigned, 

type Output = FVector3<i16, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i16, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: Self) -> Self

Performs the * operation.

impl<F> Mul<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i32, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i32, F>> for &'_ FVector2<i32, F> where
    F: Unsigned, 

type Output = FVector2<i32, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i32, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i32, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i32, F>> for &'_ FVector3<i32, F> where
    F: Unsigned, 

type Output = FVector3<i32, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i32, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: Self) -> Self

Performs the * operation.

impl<F> Mul<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i64, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i64, F>> for &'_ FVector2<i64, F> where
    F: Unsigned, 

type Output = FVector2<i64, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i64, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i64, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i64, F>> for &'_ FVector3<i64, F> where
    F: Unsigned, 

type Output = FVector3<i64, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i64, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: Self) -> Self

Performs the * operation.

impl<F> Mul<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i8, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i8, F>> for &'_ FVector2<i8, F> where
    F: Unsigned, 

type Output = FVector2<i8, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i8, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: FPN<i8, F>) -> Self

Performs the * operation.

impl<'_, F> Mul<FPN<i8, F>> for &'_ FVector3<i8, F> where
    F: Unsigned, 

type Output = FVector3<i8, F>

The resulting type after applying the * operator.

fn mul(self, v: FPN<i8, F>) -> Self::Output

Performs the * operation.

impl<F> Mul<i16> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: i16) -> Self

Performs the * operation.

impl<F> Mul<i32> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: i32) -> Self

Performs the * operation.

impl<F> Mul<i64> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: i64) -> Self

Performs the * operation.

impl<F> Mul<i8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, v: i8) -> Self

Performs the * operation.

impl<F> MulAssign<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: Self)

Performs the *= operation.

impl<F> MulAssign<FPN<i16, F>> for Vector2<FPN<i16, F>> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i16, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i16, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: Self)

Performs the *= operation.

impl<F> MulAssign<FPN<i32, F>> for Vector2<FPN<i32, F>> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i32, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i32, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: Self)

Performs the *= operation.

impl<F> MulAssign<FPN<i64, F>> for Vector2<FPN<i64, F>> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i64, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i64, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: Self)

Performs the *= operation.

impl<F> MulAssign<FPN<i8, F>> for Vector2<FPN<i8, F>> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i8, F>)

Performs the *= operation.

impl<F> MulAssign<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: FPN<i8, F>)

Performs the *= operation.

impl<F> MulAssign<i16> for FPN<i16, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: i16)

Performs the *= operation.

impl<F> MulAssign<i32> for FPN<i32, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: i32)

Performs the *= operation.

impl<F> MulAssign<i64> for FPN<i64, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: i64)

Performs the *= operation.

impl<F> MulAssign<i8> for FPN<i8, F> where
    F: Unsigned, 

fn mul_assign(&mut self, v: i8)

Performs the *= operation.

impl<F> Neg for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F> Neg for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F> Neg for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F> Neg for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I, F> Ord for FPN<I, F> where
    I: Ord, 

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<I, F> PartialEq<FPN<I, F>> for FPN<I, F> where
    I: PartialEq, 

fn eq(&self, v: &Self) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<I, F> PartialOrd<FPN<I, F>> for FPN<I, F> where
    I: PartialOrd, 

fn partial_cmp(&self, v: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F> Polar<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i16, F>

fn distance_square(&self) -> FPN<i16, F>

impl<F> Polar<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i16, F>

fn distance_square(&self) -> FPN<i16, F>

impl<F> Polar<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i32, F>

fn distance_square(&self) -> FPN<i32, F>

impl<F> Polar<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i32, F>

fn distance_square(&self) -> FPN<i32, F>

impl<F> Polar<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i64, F>

fn distance_square(&self) -> FPN<i64, F>

impl<F> Polar<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i64, F>

fn distance_square(&self) -> FPN<i64, F>

impl<F> Polar<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i8, F>

fn distance_square(&self) -> FPN<i8, F>

impl<F> Polar<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

fn polar(&self) -> Self

fn distance(&self) -> FPN<i8, F>

fn distance_square(&self) -> FPN<i8, F>

impl<F> Rem<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: Self) -> Self

Performs the % operation.

impl<F> Rem<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: Self) -> Self

Performs the % operation.

impl<F> Rem<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: Self) -> Self

Performs the % operation.

impl<F> Rem<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: Self) -> Self

Performs the % operation.

impl<F> Rem<i16> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: i16) -> Self

Performs the % operation.

impl<F> Rem<i32> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: i32) -> Self

Performs the % operation.

impl<F> Rem<i64> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: i64) -> Self

Performs the % operation.

impl<F> Rem<i8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, v: i8) -> Self

Performs the % operation.

impl<F> RemAssign<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: Self)

Performs the %= operation.

impl<F> RemAssign<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: Self)

Performs the %= operation.

impl<F> RemAssign<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: Self)

Performs the %= operation.

impl<F> RemAssign<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: Self)

Performs the %= operation.

impl<F> RemAssign<i16> for FPN<i16, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: i16)

Performs the %= operation.

impl<F> RemAssign<i32> for FPN<i32, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: i32)

Performs the %= operation.

impl<F> RemAssign<i64> for FPN<i64, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: i64)

Performs the %= operation.

impl<F> RemAssign<i8> for FPN<i8, F> where
    F: Unsigned, 

fn rem_assign(&mut self, v: i8)

Performs the %= operation.

impl<F> Rotate2<FPN<i16, F>> for FVector2<i16, F> where
    F: Unsigned, 

fn rotate(&self, v: FPN<i16, F>) -> Self

impl<F> Rotate2<FPN<i32, F>> for FVector2<i32, F> where
    F: Unsigned, 

fn rotate(&self, v: FPN<i32, F>) -> Self

impl<F> Rotate2<FPN<i64, F>> for FVector2<i64, F> where
    F: Unsigned, 

fn rotate(&self, v: FPN<i64, F>) -> Self

impl<F> Rotate2<FPN<i8, F>> for FVector2<i8, F> where
    F: Unsigned, 

fn rotate(&self, v: FPN<i8, F>) -> Self

impl<F> Rotate3<FPN<i16, F>> for FVector3<i16, F> where
    F: Unsigned, 

fn rotate_y(&self, v: FPN<i16, F>) -> Self

fn rotate_z(&self, v: FPN<i16, F>) -> Self

fn rotate_x(&self, v: FPN<i16, F>) -> Self

impl<F> Rotate3<FPN<i32, F>> for FVector3<i32, F> where
    F: Unsigned, 

fn rotate_y(&self, v: FPN<i32, F>) -> Self

fn rotate_z(&self, v: FPN<i32, F>) -> Self

fn rotate_x(&self, v: FPN<i32, F>) -> Self

impl<F> Rotate3<FPN<i64, F>> for FVector3<i64, F> where
    F: Unsigned, 

fn rotate_y(&self, v: FPN<i64, F>) -> Self

fn rotate_z(&self, v: FPN<i64, F>) -> Self

fn rotate_x(&self, v: FPN<i64, F>) -> Self

impl<F> Rotate3<FPN<i8, F>> for FVector3<i8, F> where
    F: Unsigned, 

fn rotate_y(&self, v: FPN<i8, F>) -> Self

fn rotate_z(&self, v: FPN<i8, F>) -> Self

fn rotate_x(&self, v: FPN<i8, F>) -> Self

impl<F> Shl<u8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, v: u8) -> Self

Performs the << operation.

impl<F> Shl<u8> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, v: u8) -> Self

Performs the << operation.

impl<F> Shl<u8> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, v: u8) -> Self

Performs the << operation.

impl<F> Shl<u8> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, v: u8) -> Self

Performs the << operation.

impl<F> ShlAssign<u8> for FPN<i8, F> where
    F: Unsigned, 

fn shl_assign(&mut self, v: u8)

Performs the <<= operation.

impl<F> ShlAssign<u8> for FPN<i16, F> where
    F: Unsigned, 

fn shl_assign(&mut self, v: u8)

Performs the <<= operation.

impl<F> ShlAssign<u8> for FPN<i32, F> where
    F: Unsigned, 

fn shl_assign(&mut self, v: u8)

Performs the <<= operation.

impl<F> ShlAssign<u8> for FPN<i64, F> where
    F: Unsigned, 

fn shl_assign(&mut self, v: u8)

Performs the <<= operation.

impl<F> Shr<u8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, v: u8) -> Self

Performs the >> operation.

impl<F> Shr<u8> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, v: u8) -> Self

Performs the >> operation.

impl<F> Shr<u8> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, v: u8) -> Self

Performs the >> operation.

impl<F> Shr<u8> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, v: u8) -> Self

Performs the >> operation.

impl<F> ShrAssign<u8> for FPN<i8, F> where
    F: Unsigned, 

fn shr_assign(&mut self, v: u8)

Performs the >>= operation.

impl<F> ShrAssign<u8> for FPN<i16, F> where
    F: Unsigned, 

fn shr_assign(&mut self, v: u8)

Performs the >>= operation.

impl<F> ShrAssign<u8> for FPN<i32, F> where
    F: Unsigned, 

fn shr_assign(&mut self, v: u8)

Performs the >>= operation.

impl<F> ShrAssign<u8> for FPN<i64, F> where
    F: Unsigned, 

fn shr_assign(&mut self, v: u8)

Performs the >>= operation.

impl<F> Sub<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: Self) -> Self

Performs the - operation.

impl<F> Sub<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: Self) -> Self

Performs the - operation.

impl<F> Sub<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: Self) -> Self

Performs the - operation.

impl<F> Sub<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: Self) -> Self

Performs the - operation.

impl<F> Sub<i16> for FPN<i16, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: i16) -> Self

Performs the - operation.

impl<F> Sub<i32> for FPN<i32, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: i32) -> Self

Performs the - operation.

impl<F> Sub<i64> for FPN<i64, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: i64) -> Self

Performs the - operation.

impl<F> Sub<i8> for FPN<i8, F> where
    F: Unsigned, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, v: i8) -> Self

Performs the - operation.

impl<F> SubAssign<FPN<i16, F>> for FPN<i16, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: Self)

Performs the -= operation.

impl<F> SubAssign<FPN<i32, F>> for FPN<i32, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: Self)

Performs the -= operation.

impl<F> SubAssign<FPN<i64, F>> for FPN<i64, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: Self)

Performs the -= operation.

impl<F> SubAssign<FPN<i8, F>> for FPN<i8, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: Self)

Performs the -= operation.

impl<F> SubAssign<i16> for FPN<i16, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: i16)

Performs the -= operation.

impl<F> SubAssign<i32> for FPN<i32, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: i32)

Performs the -= operation.

impl<F> SubAssign<i64> for FPN<i64, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: i64)

Performs the -= operation.

impl<F> SubAssign<i8> for FPN<i8, F> where
    F: Unsigned, 

fn sub_assign(&mut self, v: i8)

Performs the -= operation.

impl<FF, FT> To<FPN<i16, FT>> for FPN<i8, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i16, FT>

impl<FF, FT> To<FPN<i16, FT>> for FPN<i16, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i16, FT>

impl<FF, FT> To<FPN<i16, FT>> for FPN<i32, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i16, FT>

impl<FF, FT> To<FPN<i16, FT>> for FPN<i64, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i16, FT>

impl<FF, FT> To<FPN<i32, FT>> for FPN<i8, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i32, FT>

impl<FF, FT> To<FPN<i32, FT>> for FPN<i16, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i32, FT>

impl<FF, FT> To<FPN<i32, FT>> for FPN<i32, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i32, FT>

impl<FF, FT> To<FPN<i32, FT>> for FPN<i64, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i32, FT>

impl<FF, FT> To<FPN<i64, FT>> for FPN<i8, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i64, FT>

impl<FF, FT> To<FPN<i64, FT>> for FPN<i16, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i64, FT>

impl<FF, FT> To<FPN<i64, FT>> for FPN<i32, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i64, FT>

impl<FF, FT> To<FPN<i64, FT>> for FPN<i64, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i64, FT>

impl<FF, FT> To<FPN<i8, FT>> for FPN<i8, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i8, FT>

impl<FF, FT> To<FPN<i8, FT>> for FPN<i16, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i8, FT>

impl<FF, FT> To<FPN<i8, FT>> for FPN<i32, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i8, FT>

impl<FF, FT> To<FPN<i8, FT>> for FPN<i64, FF> where
    FF: Unsigned,
    FT: Unsigned, 

fn to(&self) -> FPN<i8, FT>