Struct Qty 

pub struct Qty<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8>(/* private fields */);

A quantity, with the seven SI base dimensions in its type.

The parameters are the exponents of metre, kilogram, second, ampere, kelvin, mole and candela, in that order, so a velocity (m·s⁻¹) is Qty<1,0,-1,0,0,0,0> — which is what Velocity names.

Addition, subtraction, negation, comparison and scaling by a plain f64 work for every dimension. Multiplication and division between two quantities work for the pairs declared in this module.

Implementations

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Qty<L, M, T, I, K, N, J>

pub const ZERO: Qty<L, M, T, I, K, N, J>

Zero, which is the one value every dimension shares.

pub const fn from_si(value: f64) -> Qty<L, M, T, I, K, N, J>

Wrap a number already in SI base units. The escape hatch: use it when a dimension has no name here, and name it if you use it twice.

const, so a dimensioned constant can be written without a lazy static.

pub const fn to_si(self) -> f64

The value in SI base units.

pub const fn dimension() -> [i8; 7]

The seven exponents, for diagnostics and for a runtime dimension check at a boundary the type system does not cross (deserialisation, FFI).

pub fn abs(self) -> Qty<L, M, T, I, K, N, J>

Magnitude without its sign, in the same dimension.

pub fn min(self, other: Qty<L, M, T, I, K, N, J>) -> Qty<L, M, T, I, K, N, J>

The smaller of two quantities of the same dimension.

pub fn max(self, other: Qty<L, M, T, I, K, N, J>) -> Qty<L, M, T, I, K, N, J>

The larger of two quantities of the same dimension.

pub fn is_finite(self) -> bool

Whether the magnitude is neither infinite nor NaN.

Worth checking where a limit is reported rather than computed: several methods here return an infinity to mean “no limit”, which is honest but arithmetic on it is not.

pub fn signum(self) -> f64

Sign of the magnitude, as a plain number — a sign has no dimension.

pub fn lerp( self, other: Qty<L, M, T, I, K, N, J>, t: f64, ) -> Qty<L, M, T, I, K, N, J>

Linear interpolation, which stays within the dimension.

impl Qty<2, 0, 0, 0, 0, 0, 0>

pub fn sqrt(self) -> Qty<1, 0, 0, 0, 0, 0, 0>

The side of a square of this area. The one root worth naming, because it is how a beam radius comes back out of a spot area.

impl Qty<1, 0, 0, 0, 0, 0, 0>

pub fn m(v: f64) -> Qty<1, 0, 0, 0, 0, 0, 0>

Metres.

pub fn mm(v: f64) -> Qty<1, 0, 0, 0, 0, 0, 0>

Millimetres.

pub fn um(v: f64) -> Qty<1, 0, 0, 0, 0, 0, 0>

Micrometres.

pub fn nm(v: f64) -> Qty<1, 0, 0, 0, 0, 0, 0>

Nanometres. The wavelength unit, and why every Spectrum field is named _nm.

pub fn in_mm(self) -> f64

As millimetres.

pub fn in_um(self) -> f64

As micrometres.

pub fn in_nm(self) -> f64

As nanometres.

impl Qty<0, 0, 1, 0, 0, 0, 0>

pub fn s(v: f64) -> Qty<0, 0, 1, 0, 0, 0, 0>

Seconds.

pub fn ms(v: f64) -> Qty<0, 0, 1, 0, 0, 0, 0>

Milliseconds.

pub fn us(v: f64) -> Qty<0, 0, 1, 0, 0, 0, 0>

Microseconds.

pub fn ns(v: f64) -> Qty<0, 0, 1, 0, 0, 0, 0>

Nanoseconds.

pub fn in_ms(self) -> f64

As milliseconds.

pub fn in_us(self) -> f64

As microseconds.

impl Qty<0, 0, 0, 0, 1, 0, 0>

pub fn kelvin(v: f64) -> Qty<0, 0, 0, 0, 1, 0, 0>

Kelvin, which is what is stored.

pub fn celsius(v: f64) -> Qty<0, 0, 0, 0, 1, 0, 0>

Celsius is an offset scale, not a scaled one, which is why it gets a named constructor rather than a factor: 20 °C is 293.15 K, and a temperature difference of 20 K is a different thing entirely.

pub fn in_celsius(self) -> f64

As degrees Celsius. Subtracts the offset; see Temperature::celsius.

impl Qty<0, 1, 0, 0, 0, 0, 0>

pub fn kg(v: f64) -> Qty<0, 1, 0, 0, 0, 0, 0>

Kilograms.

pub fn g(v: f64) -> Qty<0, 1, 0, 0, 0, 0, 0>

Grams.

impl Qty<-3, 1, 0, 0, 0, 0, 0>

pub fn g_per_cm3(v: f64) -> Qty<-3, 1, 0, 0, 0, 0, 0>

The way a glass catalogue quotes it: N-BK7 is 2.51 g/cm³.

pub fn kg_per_m3(v: f64) -> Qty<-3, 1, 0, 0, 0, 0, 0>

Kilograms per cubic metre, which is what is stored.

impl Qty<2, 1, -3, 0, 0, 0, 0>

pub fn w(v: f64) -> Qty<2, 1, -3, 0, 0, 0, 0>

Watts.

pub fn mw(v: f64) -> Qty<2, 1, -3, 0, 0, 0, 0>

Milliwatts.

pub fn uw(v: f64) -> Qty<2, 1, -3, 0, 0, 0, 0>

Microwatts.

pub fn in_mw(self) -> f64

As milliwatts.

impl Qty<2, 1, -2, 0, 0, 0, 0>

pub fn j(v: f64) -> Qty<2, 1, -2, 0, 0, 0, 0>

Joules.

pub fn mj(v: f64) -> Qty<2, 1, -2, 0, 0, 0, 0>

Millijoules.

impl Qty<0, 0, -1, 0, 0, 0, 0>

pub fn hz(v: f64) -> Qty<0, 0, -1, 0, 0, 0, 0>

Hertz.

pub fn khz(v: f64) -> Qty<0, 0, -1, 0, 0, 0, 0>

Kilohertz.

pub fn mhz(v: f64) -> Qty<0, 0, -1, 0, 0, 0, 0>

Megahertz.

pub fn period(self) -> Qty<0, 0, 1, 0, 0, 0, 0>

Period: one over the frequency. Named because 1.0 / f cannot typecheck.

impl Qty<1, 0, -1, 0, 0, 0, 0>

pub fn m_per_s(v: f64) -> Qty<1, 0, -1, 0, 0, 0, 0>

Metres per second.

pub fn mm_per_s(v: f64) -> Qty<1, 0, -1, 0, 0, 0, 0>

Millimetres per second.

impl Qty<0, 1, -3, 0, 0, 0, 0>

pub fn w_per_m2(v: f64) -> Qty<0, 1, -3, 0, 0, 0, 0>

Watts per square metre, which is what is stored.

pub fn mw_per_cm2(v: f64) -> Qty<0, 1, -3, 0, 0, 0, 0>

How an illumination spec is usually written: mW/cm².

impl Qty<1, 1, -3, 0, -1, 0, 0>

pub fn w_per_m_k(v: f64) -> Qty<1, 1, -3, 0, -1, 0, 0>

W·m⁻¹·K⁻¹, the unit a materials table uses.

impl Qty<2, 0, -2, 0, -1, 0, 0>

pub fn j_per_kg_k(v: f64) -> Qty<2, 0, -2, 0, -1, 0, 0>

J·kg⁻¹·K⁻¹, the unit a materials table uses.

impl Qty<2, 1, -3, 0, -1, 0, 0>

pub fn w_per_k(v: f64) -> Qty<2, 1, -3, 0, -1, 0, 0>

Watts per kelvin.

impl Qty<2, 1, -2, 0, -1, 0, 0>

pub fn j_per_k(v: f64) -> Qty<2, 1, -2, 0, -1, 0, 0>

Joules per kelvin. The companion to Conductance::w_per_k: their ratio is a time constant, and the type system says so.

impl Qty<0, 0, 0, 0, -1, 0, 0>

pub fn ppm_per_k(v: f64) -> Qty<0, 0, 0, 0, -1, 0, 0>

Catalogues quote it in parts per million per kelvin: N-BK7 is 7.1.

impl Qty<0, 0, 0, 0, 0, 0, 0>

pub fn ratio(v: f64) -> Qty<0, 0, 0, 0, 0, 0, 0>

A bare ratio, for the one case where a number genuinely has no dimension: a reflectance, a duty cycle, a refractive index.

Trait Implementations

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Add for Qty<L, M, T, I, K, N, J>

type Output = Qty<L, M, T, I, K, N, J>

The resulting type after applying the + operator.

fn add(self, rhs: Qty<L, M, T, I, K, N, J>) -> Qty<L, M, T, I, K, N, J>

Performs the + operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> AddAssign for Qty<L, M, T, I, K, N, J>

fn add_assign(&mut self, rhs: Qty<L, M, T, I, K, N, J>)

Performs the += operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Clone for Qty<L, M, T, I, K, N, J>

fn clone(&self) -> Qty<L, M, T, I, K, N, J>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Copy for Qty<L, M, T, I, K, N, J>

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Debug for Qty<L, M, T, I, K, N, J>

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

Formats the value using the given formatter.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Default for Qty<L, M, T, I, K, N, J>

fn default() -> Qty<L, M, T, I, K, N, J>

Returns the “default value” for a type.

impl<'de, const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Deserialize<'de> for Qty<L, M, T, I, K, N, J>

fn deserialize<D>( d: D, ) -> Result<Qty<L, M, T, I, K, N, J>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Display for Qty<L, M, T, I, K, N, J>

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

Formats the value using the given formatter.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Div for Qty<L, M, T, I, K, N, J>

Dividing two quantities of the same dimension gives a plain number — which is the one product rule that needs no exponent arithmetic, and the one every tolerance check uses.

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: Qty<L, M, T, I, K, N, J>) -> f64

Performs the / operation.

impl Div<Qty<0, 0, 0, 0, 1, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, -1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 0, 0, 1, 0, 0>) -> Qty<2, 1, -3, 0, -1, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 0, 0, 1, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, -1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 0, 0, 1, 0, 0>) -> Qty<2, 1, -2, 0, -1, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 0, 1, 0, 0, 0>> for Qty<0, 0, 1, 1, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 0, 1, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 0, 1, 0, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<2, 1, -3, -1, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 0, 1, 0, 0, 0>) -> Qty<2, 1, -3, -1, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, 0, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 0, -1, 0, 0, 0, 0>

type Output = Qty<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 1, -1, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<0, 0, 1, 1, 0, 0, 0>

type Output = Qty<0, 0, 0, 1, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<0, 0, 0, 1, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, -1, 0, 0>

type Output = Qty<2, 1, -3, 0, -1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<2, 1, -3, 0, -1, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<0, 0, 0, 0, 0, 0, 0>

type Output = Qty<0, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<0, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, -1, 0, 0, 0, 0>> for Qty<2, 1, -1, 0, 0, 0, 0>

type Output = Qty<2, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, -1, 0, 0, 0, 0>) -> Qty<2, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, -1, 0, 0, 0, 0>> for Qty<0, 0, 0, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 0, -1, 0, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<1, 1, -1, 0, 0, 0, 0>

type Output = Qty<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<2, 1, 0, 0, 0, 0, 0>

type Output = Qty<2, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<2, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, -1, 0, 0>

type Output = Qty<2, 0, -2, 0, -1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<2, 0, -2, 0, -1, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -1, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, -1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -1, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, -1, 0, 0, 0, 0>) -> Qty<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -2, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -2, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, -2, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -3, 0, 0, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<2, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<0, 1, -3, 0, 0, 0, 0>) -> Qty<2, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<2, 0, 0, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<3, 0, 0, 0, 0, 0, 0>

type Output = Qty<2, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<2, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<0, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<0, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<1, 1, -1, 0, 0, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<0, 1, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<0, 1, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, -2, 0, 0, 0, 0>> for Qty<1, 0, -1, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, -2, 0, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 0, -2, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 0, -2, 0, 0, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 1, -2, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 1, -2, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<1, 1, -2, 0, 0, 0, 0>> for Qty<1, 1, -1, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<1, 1, -2, 0, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<3, 0, 0, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<-1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<-1, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<0, 1, -3, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<0, 1, -3, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<2, 1, 0, 0, 0, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 0, -2, 0, -1, 0, 0>> for Qty<2, 1, -2, 0, -1, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 0, -2, 0, -1, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, 0, 0, 0, 0, 0>> for Qty<2, 1, -1, 0, 0, 0, 0>

type Output = Qty<0, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, 0, 0, 0, 0, 0>) -> Qty<0, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, -2, 0, -1, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<0, 0, 0, 0, 1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, -2, 0, -1, 0, 0>) -> Qty<0, 0, 0, 0, 1, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, -3, 0, 0, 0, 0>> for Qty<2, 1, -2, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, -3, 0, 0, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, -3, 0, -1, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<0, 0, 0, 0, 1, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, -3, 0, -1, 0, 0>) -> Qty<0, 0, 0, 0, 1, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, -3, 0, -1, 0, 0>> for Qty<2, 1, -2, 0, -1, 0, 0>

type Output = Qty<0, 0, 1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, -3, 0, -1, 0, 0>) -> Qty<0, 0, 1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<2, 1, -3, -1, 0, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<0, 0, 0, 1, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<2, 1, -3, -1, 0, 0, 0>) -> Qty<0, 0, 0, 1, 0, 0, 0>

Performs the / operation.

impl Div<Qty<3, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<-3, 1, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<3, 0, 0, 0, 0, 0, 0>) -> Qty<-3, 1, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<-1, 1, -2, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<2, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<-1, 1, -2, 0, 0, 0, 0>) -> Qty<2, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<-3, 1, 0, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<3, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, rhs: Qty<-3, 1, 0, 0, 0, 0, 0>) -> Qty<3, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Div<f64> for Qty<L, M, T, I, K, N, J>

type Output = Qty<L, M, T, I, K, N, J>

The resulting type after applying the / operator.

fn div(self, k: f64) -> Qty<L, M, T, I, K, N, J>

Performs the / operation.

impl Mul for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<2, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<2, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -2, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 1, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 0, 0, 1, 0, 0>> for Qty<2, 1, -3, 0, -1, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 0, 0, 1, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 0, 0, 1, 0, 0>> for Qty<2, 1, -2, 0, -1, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 0, 0, 1, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 0, 1, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<0, 0, 1, 1, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 0, 1, 0, 0, 0>) -> Qty<0, 0, 1, 1, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 0, 1, 0, 0, 0>> for Qty<2, 1, -3, -1, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 0, 1, 0, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 0, -1, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 0, -2, 0, 0, 0, 0>

type Output = Qty<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<2, 1, -3, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<0, 0, 0, 1, 0, 0, 0>

type Output = Qty<0, 0, 1, 1, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<0, 0, 1, 1, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<2, 1, -3, 0, -1, 0, 0>

type Output = Qty<2, 1, -2, 0, -1, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, -1, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for Qty<0, 0, -1, 0, 0, 0, 0>

type Output = Qty<0, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, 1, 0, 0, 0, 0>) -> Qty<0, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, -1, 0, 0, 0, 0>> for Qty<2, 1, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, -1, 0, 0, 0, 0>) -> Qty<2, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, -1, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<0, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 0, -1, 0, 0, 0, 0>) -> Qty<0, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 0, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<1, 0, -2, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<1, 0, -1, 0, 0, 0, 0>

type Output = Qty<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<2, 0, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<2, 1, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for Qty<2, 0, -2, 0, -1, 0, 0>

type Output = Qty<2, 1, -2, 0, -1, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, 0, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, -1, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -1, 0, 0, 0, 0>> for Qty<1, 0, -1, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, -1, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -2, 0, 0, 0, 0>> for QVec3<1, 0, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -2, 0, 0, 0, 0>> for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, -2, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -3, 0, 0, 0, 0>> for Qty<2, 0, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<0, 1, -3, 0, 0, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<2, 0, 0, 0, 0, 0, 0>

type Output = Qty<3, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<3, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<1, 1, -2, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, 0, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, -1, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, -1, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, -2, 0, 0, 0, 0>) -> Qty<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 0, -2, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 1, -2, 0, 0, 0, 0>> for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 1, -2, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<1, 1, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<1, 1, -2, 0, 0, 0, 0>) -> Qty<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<1, 0, 0, 0, 0, 0, 0>

type Output = Qty<3, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<3, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<-1, 1, -2, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, -3, 0, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 0, 0, 0, 0, 0, 0>) -> Qty<2, 1, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 0, -2, 0, -1, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, -1, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 0, -2, 0, -1, 0, 0>) -> Qty<2, 1, -2, 0, -1, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, 0, 0, 0, 0, 0>> for Qty<0, 0, -1, 0, 0, 0, 0>

type Output = Qty<2, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, 0, 0, 0, 0, 0>) -> Qty<2, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, -2, 0, -1, 0, 0>> for Qty<0, 0, 0, 0, 1, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, -2, 0, -1, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, -3, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, -3, 0, 0, 0, 0>) -> Qty<2, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, -3, 0, -1, 0, 0>> for Qty<0, 0, 0, 0, 1, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, -3, 0, -1, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, -3, 0, -1, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = Qty<2, 1, -2, 0, -1, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, -3, 0, -1, 0, 0>) -> Qty<2, 1, -2, 0, -1, 0, 0>

Performs the * operation.

impl Mul<Qty<2, 1, -3, -1, 0, 0, 0>> for Qty<0, 0, 0, 1, 0, 0, 0>

type Output = Qty<2, 1, -3, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<2, 1, -3, -1, 0, 0, 0>) -> Qty<2, 1, -3, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<3, 0, 0, 0, 0, 0, 0>> for Qty<-3, 1, 0, 0, 0, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<3, 0, 0, 0, 0, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<-1, 1, -2, 0, 0, 0, 0>> for Qty<2, 0, 0, 0, 0, 0, 0>

type Output = Qty<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<-1, 1, -2, 0, 0, 0, 0>) -> Qty<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<-3, 1, 0, 0, 0, 0, 0>> for Qty<3, 0, 0, 0, 0, 0, 0>

type Output = Qty<0, 1, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, rhs: Qty<-3, 1, 0, 0, 0, 0, 0>) -> Qty<0, 1, 0, 0, 0, 0, 0>

Performs the * operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Mul<f64> for Qty<L, M, T, I, K, N, J>

type Output = Qty<L, M, T, I, K, N, J>

The resulting type after applying the * operator.

fn mul(self, k: f64) -> Qty<L, M, T, I, K, N, J>

Performs the * operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Neg for Qty<L, M, T, I, K, N, J>

type Output = Qty<L, M, T, I, K, N, J>

The resulting type after applying the - operator.

fn neg(self) -> Qty<L, M, T, I, K, N, J>

Performs the unary - operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> PartialEq for Qty<L, M, T, I, K, N, J>

fn eq(&self, other: &Qty<L, M, T, I, K, N, J>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> PartialOrd for Qty<L, M, T, I, K, N, J>

fn partial_cmp(&self, other: &Qty<L, M, T, I, K, N, J>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Serialize for Qty<L, M, T, I, K, N, J>

fn serialize<S>( &self, s: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> StructuralPartialEq for Qty<L, M, T, I, K, N, J>

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Sub for Qty<L, M, T, I, K, N, J>

type Output = Qty<L, M, T, I, K, N, J>

The resulting type after applying the - operator.

fn sub(self, rhs: Qty<L, M, T, I, K, N, J>) -> Qty<L, M, T, I, K, N, J>

Performs the - operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> SubAssign for Qty<L, M, T, I, K, N, J>

fn sub_assign(&mut self, rhs: Qty<L, M, T, I, K, N, J>)

Performs the -= operation.