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: Self

Zero, which is the one value every dimension shares.

pub const fn from_si(value: f64) -> Self

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) -> Self

Magnitude without its sign, in the same dimension.

pub fn min(self, other: Self) -> Self

The smaller of two quantities of the same dimension.

pub fn max(self, other: Self) -> Self

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: Self, t: f64) -> Self

Linear interpolation, which stays within the dimension.

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

pub fn m3(v: f64) -> Volume

Cubic metres.

pub fn cm3(v: f64) -> Volume

Cubic centimetres — the unit a person actually has for a part.

pub fn mm3(v: f64) -> Volume

Cubic millimetres.

pub fn litres(v: f64) -> Volume

Litres.

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

pub fn m2(v: f64) -> Area

Square metres.

pub fn cm2(v: f64) -> Area

Square centimetres.

pub fn mm2(v: f64) -> Area

Square millimetres — wire cross-sections live here.

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

pub fn sqrt(self) -> Length

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<3, 1, -3, -2, 0, 0, 0>

pub fn ohm_m(v: f64) -> Resistivity

Ohm-metres. Copper is 1.724e-8 at 20 °C, aluminium 2.65e-8, and a resistor’s ceramic substrate is fourteen orders of magnitude up from either.

pub fn micro_ohm_cm(v: f64) -> Resistivity

µΩ·cm, which is what a materials datasheet quotes: copper is 1.724.

pub fn conductivity(self) -> Conductivity

The conductivity that is its reciprocal. Zero resistivity gives an infinite conductivity, which is the honest answer and not a panic.

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

pub fn s_per_m(v: f64) -> Conductivity

Siemens per metre.

pub fn resistivity(self) -> Resistivity

The resistivity that is its reciprocal.

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

pub fn v_per_m(v: f64) -> ElectricField

Volts per metre.

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

pub fn a_per_m2(v: f64) -> CurrentDensity

Amperes per square metre.

pub fn a_per_mm2(v: f64) -> CurrentDensity

A/mm², which is how a cable’s rating is quoted — 5 A/mm² is a normal continuous figure for insulated copper in air.

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

pub fn ohm(v: f64) -> Resistance

Ohms.

pub fn milliohm(v: f64) -> Resistance

Milliohms — the range a motor winding or a shunt actually lives in.

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

pub fn a(v: f64) -> Current

Amperes.

pub fn ma(v: f64) -> Current

Milliamperes.

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

pub fn v(v: f64) -> Voltage

Volts.

pub fn mv(v: f64) -> Voltage

Millivolts.

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

pub fn m(v: f64) -> Length

Metres.

pub fn mm(v: f64) -> Length

Millimetres.

pub fn um(v: f64) -> Length

Micrometres.

pub fn nm(v: f64) -> Length

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) -> Time

Seconds.

pub fn ms(v: f64) -> Time

Milliseconds.

pub fn us(v: f64) -> Time

Microseconds.

pub fn ns(v: f64) -> Time

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) -> Temperature

Kelvin, which is what is stored.

pub fn celsius(v: f64) -> Temperature

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) -> Mass

Kilograms.

pub fn g(v: f64) -> Mass

Grams.

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

pub fn g_per_cm3(v: f64) -> Density

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

pub fn kg_per_m3(v: f64) -> Density

Kilograms per cubic metre, which is what is stored.

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

pub fn w(v: f64) -> Power

Watts.

pub fn mw(v: f64) -> Power

Milliwatts.

pub fn uw(v: f64) -> Power

Microwatts.

pub fn in_mw(self) -> f64

As milliwatts.

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

pub fn j(v: f64) -> Energy

Joules.

pub fn mj(v: f64) -> Energy

Millijoules.

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

pub fn hz(v: f64) -> Frequency

Hertz.

pub fn khz(v: f64) -> Frequency

Kilohertz.

pub fn mhz(v: f64) -> Frequency

Megahertz.

pub fn period(self) -> Time

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) -> Velocity

Metres per second.

pub fn mm_per_s(v: f64) -> Velocity

Millimetres per second.

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

pub fn w_per_m2(v: f64) -> Irradiance

Watts per square metre, which is what is stored.

pub fn mw_per_cm2(v: f64) -> Irradiance

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) -> ThermalConductivity

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) -> SpecificHeat

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

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

pub fn j_per_kg(v: f64) -> LatentHeat

J·kg⁻¹.

pub fn kj_per_kg(v: f64) -> LatentHeat

kJ·kg⁻¹, which is the unit every table of latent heats is written in.

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

pub fn w_per_k(v: f64) -> Conductance

Watts per kelvin.

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

pub fn j_per_k(v: f64) -> HeatCapacity

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) -> ThermalExpansion

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) -> Dimensionless

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: Self) -> Self

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: Self)

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

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: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

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

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: Self) -> f64

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Temperature) -> SpecificHeat

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Temperature) -> Conductance

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Temperature) -> HeatCapacity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Current) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Current) -> Voltage

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Current) -> Resistance

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Time) -> VelocityVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Time) -> AccelerationVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Time) -> ForceVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Velocity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Acceleration

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Force

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Power

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Current

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Conductance

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Time) -> Frequency

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Frequency) -> MomentOfInertia

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Frequency) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Mass) -> VelocityVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Mass) -> AccelerationVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Mass) -> Acceleration

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Mass) -> Velocity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Mass) -> Area

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Mass) -> SpecificHeat

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Mass) -> LatentHeat

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Damping) -> VelocityVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Damping) -> Velocity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, k: Stiffness) -> LengthVec

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Stiffness) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Irradiance) -> Area

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> Area

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> Force

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> Resistance

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> ElectricField

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Length) -> Stiffness

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Velocity) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Velocity) -> Mass

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Velocity) -> Damping

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Acceleration) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Acceleration) -> Mass

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Force) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Force) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ElectricField) -> Conductivity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ElectricField) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Area) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Area) -> Pressure

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Area) -> Irradiance

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Area) -> CurrentDensity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Area) -> Mass

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: LatentHeat) -> Mass

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: SpecificHeat) -> Mass

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: SpecificHeat) -> Temperature

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: MomentOfInertia) -> Frequency

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: HeatCapacity) -> Temperature

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Power) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Conductance) -> Temperature

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Conductance) -> Time

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Voltage) -> Current

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Resistance) -> Current

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Resistance) -> Length

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Volume) -> Density

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Resistivity) -> CurrentDensity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Pressure) -> Area

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: CurrentDensity) -> Resistivity

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: CurrentDensity) -> Area

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Density) -> Volume

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Conductivity) -> ElectricField

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) -> Self

Performs the / operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Temperature) -> LatentHeat

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Temperature) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Temperature) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Current) -> Charge

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Current) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Current) -> Voltage

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Time) -> LengthVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Time) -> VelocityVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Time) -> MomentumVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Length

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Velocity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Momentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Charge

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> HeatCapacity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Time) -> Dimensionless

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Frequency) -> AngularMomentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Frequency) -> Dimensionless

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Mass) -> MomentumVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Mass) -> ForceVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mass) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mass) -> Momentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mass) -> MomentOfInertia

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mass) -> HeatCapacity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mass) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Damping) -> ForceVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Damping) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, k: Stiffness) -> ForceVec

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Stiffness) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Irradiance) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Length) -> Volume

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Length) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Length) -> Resistivity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Length) -> Voltage

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Length) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Velocity) -> Length

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Velocity) -> Momentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Velocity) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Acceleration) -> Velocity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Acceleration) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Force) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Force) -> Momentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: ElectricField) -> CurrentDensity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: ElectricField) -> Voltage

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Area) -> Volume

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Area) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Area) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Area) -> Current

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Area) -> MomentOfInertia

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: LatentHeat) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: SpecificHeat) -> HeatCapacity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: SpecificHeat) -> LatentHeat

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: MomentOfInertia) -> AngularMomentum

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: HeatCapacity) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Power) -> Energy

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Conductance) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Conductance) -> HeatCapacity

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Voltage) -> Power

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Resistance) -> Voltage

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Resistance) -> Resistivity

Performs the * operation.

impl Mul<Qty<3, 0, 0, 0, 0, 0, 0>> for Density

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

The resulting type after applying the * operator.

fn mul(self, rhs: Volume) -> Mass

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Resistivity) -> ElectricField

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Pressure) -> Force

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: CurrentDensity) -> ElectricField

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: CurrentDensity) -> Current

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Density) -> Mass

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Conductivity) -> CurrentDensity

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<Qty<L, M, T, I, K, N, J>> for f64

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

The resulting type after applying the * operator.

fn mul(self, q: 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> 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) -> Self

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) -> Self

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: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

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: Self) -> Self

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: Self)

Performs the -= operation.