simple_si_units/
electromagnetic.rs

1
2//! This module provides electromagnetic SI units, such as inverse of illuminance 
3//! and inverse of magnetic flux.
4use core::fmt;
5use super::UnitStruct;
6use super::NumLike;
7use super::base::*;
8use super::geometry::*;
9use super::mechanical::*;
10
11// optional supports
12#[cfg(feature="serde")]
13use serde::{Serialize, Deserialize};
14#[cfg(feature="num-bigfloat")]
15use num_bigfloat;
16#[cfg(feature="num-complex")]
17use num_complex;
18
19
20
21/// The inverse of illuminance unit type, defined as square meters per lumen in SI units
22#[derive(UnitStruct, Debug, Clone)]
23#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
24pub struct AreaPerLumen<T: NumLike>{
25	/// The value of this Area per lumen in square meters per lumen
26	pub m2_per_lm: T
27}
28
29impl<T> AreaPerLumen<T> where T: NumLike {
30
31	/// Returns the standard unit name of area per lumen: "square meters per lumen"
32	pub fn unit_name() -> &'static str { "square meters per lumen" }
33	
34	/// Returns the abbreviated name or symbol of area per lumen: "m²/lm" for square meters per lumen
35	pub fn unit_symbol() -> &'static str { "m²/lm" }
36	
37	/// Returns a new area per lumen value from the given number of square meters per lumen
38	///
39	/// # Arguments
40	/// * `m2_per_lm` - Any number-like type, representing a quantity of square meters per lumen
41	pub fn from_m2_per_lm(m2_per_lm: T) -> Self { AreaPerLumen{m2_per_lm: m2_per_lm} }
42	
43	/// Returns a copy of this area per lumen value in square meters per lumen
44	pub fn to_m2_per_lm(&self) -> T { self.m2_per_lm.clone() }
45
46	/// Returns a new area per lumen value from the given number of square meters per lumen
47	///
48	/// # Arguments
49	/// * `square_meters_per_lumen` - Any number-like type, representing a quantity of square meters per lumen
50	pub fn from_square_meters_per_lumen(square_meters_per_lumen: T) -> Self { AreaPerLumen{m2_per_lm: square_meters_per_lumen} }
51	
52	/// Returns a copy of this area per lumen value in square meters per lumen
53	pub fn to_square_meters_per_lumen(&self) -> T { self.m2_per_lm.clone() }
54
55	/// Returns a new area per lumen value from the given number of inverse lux
56	///
57	/// # Arguments
58	/// * `per_lux` - Any number-like type, representing a quantity of square meters per lumen
59	pub fn from_per_lux(per_lux: T) -> Self { AreaPerLumen{m2_per_lm: per_lux} }
60	
61	/// Returns a copy of this area per lumen value in inverse lux
62	pub fn to_per_lux(&self) -> T { self.m2_per_lm.clone() }
63
64}
65
66impl<T> fmt::Display for AreaPerLumen<T> where T: NumLike {
67	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
68		write!(f, "{} {}", &self.m2_per_lm, Self::unit_symbol())
69	}
70}
71
72impl<T> AreaPerLumen<T> where T: NumLike+From<f64> {
73	
74}
75
76
77/// Multiplying a unit value by a scalar value returns a unit value
78#[cfg(feature="num-bigfloat")]
79impl core::ops::Mul<AreaPerLumen<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
80	type Output = AreaPerLumen<num_bigfloat::BigFloat>;
81	fn mul(self, rhs: AreaPerLumen<num_bigfloat::BigFloat>) -> Self::Output {
82		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm}
83	}
84}
85/// Multiplying a unit value by a scalar value returns a unit value
86#[cfg(feature="num-bigfloat")]
87impl core::ops::Mul<AreaPerLumen<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
88	type Output = AreaPerLumen<num_bigfloat::BigFloat>;
89	fn mul(self, rhs: AreaPerLumen<num_bigfloat::BigFloat>) -> Self::Output {
90		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm}
91	}
92}
93/// Multiplying a unit value by a scalar value returns a unit value
94#[cfg(feature="num-bigfloat")]
95impl core::ops::Mul<&AreaPerLumen<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
96	type Output = AreaPerLumen<num_bigfloat::BigFloat>;
97	fn mul(self, rhs: &AreaPerLumen<num_bigfloat::BigFloat>) -> Self::Output {
98		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm.clone()}
99	}
100}
101/// Multiplying a unit value by a scalar value returns a unit value
102#[cfg(feature="num-bigfloat")]
103impl core::ops::Mul<&AreaPerLumen<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
104	type Output = AreaPerLumen<num_bigfloat::BigFloat>;
105	fn mul(self, rhs: &AreaPerLumen<num_bigfloat::BigFloat>) -> Self::Output {
106		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm.clone()}
107	}
108}
109
110/// Multiplying a unit value by a scalar value returns a unit value
111#[cfg(feature="num-complex")]
112impl core::ops::Mul<AreaPerLumen<num_complex::Complex32>> for num_complex::Complex32 {
113	type Output = AreaPerLumen<num_complex::Complex32>;
114	fn mul(self, rhs: AreaPerLumen<num_complex::Complex32>) -> Self::Output {
115		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm}
116	}
117}
118/// Multiplying a unit value by a scalar value returns a unit value
119#[cfg(feature="num-complex")]
120impl core::ops::Mul<AreaPerLumen<num_complex::Complex32>> for &num_complex::Complex32 {
121	type Output = AreaPerLumen<num_complex::Complex32>;
122	fn mul(self, rhs: AreaPerLumen<num_complex::Complex32>) -> Self::Output {
123		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm}
124	}
125}
126/// Multiplying a unit value by a scalar value returns a unit value
127#[cfg(feature="num-complex")]
128impl core::ops::Mul<&AreaPerLumen<num_complex::Complex32>> for num_complex::Complex32 {
129	type Output = AreaPerLumen<num_complex::Complex32>;
130	fn mul(self, rhs: &AreaPerLumen<num_complex::Complex32>) -> Self::Output {
131		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm.clone()}
132	}
133}
134/// Multiplying a unit value by a scalar value returns a unit value
135#[cfg(feature="num-complex")]
136impl core::ops::Mul<&AreaPerLumen<num_complex::Complex32>> for &num_complex::Complex32 {
137	type Output = AreaPerLumen<num_complex::Complex32>;
138	fn mul(self, rhs: &AreaPerLumen<num_complex::Complex32>) -> Self::Output {
139		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm.clone()}
140	}
141}
142
143/// Multiplying a unit value by a scalar value returns a unit value
144#[cfg(feature="num-complex")]
145impl core::ops::Mul<AreaPerLumen<num_complex::Complex64>> for num_complex::Complex64 {
146	type Output = AreaPerLumen<num_complex::Complex64>;
147	fn mul(self, rhs: AreaPerLumen<num_complex::Complex64>) -> Self::Output {
148		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm}
149	}
150}
151/// Multiplying a unit value by a scalar value returns a unit value
152#[cfg(feature="num-complex")]
153impl core::ops::Mul<AreaPerLumen<num_complex::Complex64>> for &num_complex::Complex64 {
154	type Output = AreaPerLumen<num_complex::Complex64>;
155	fn mul(self, rhs: AreaPerLumen<num_complex::Complex64>) -> Self::Output {
156		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm}
157	}
158}
159/// Multiplying a unit value by a scalar value returns a unit value
160#[cfg(feature="num-complex")]
161impl core::ops::Mul<&AreaPerLumen<num_complex::Complex64>> for num_complex::Complex64 {
162	type Output = AreaPerLumen<num_complex::Complex64>;
163	fn mul(self, rhs: &AreaPerLumen<num_complex::Complex64>) -> Self::Output {
164		AreaPerLumen{m2_per_lm: self * rhs.m2_per_lm.clone()}
165	}
166}
167/// Multiplying a unit value by a scalar value returns a unit value
168#[cfg(feature="num-complex")]
169impl core::ops::Mul<&AreaPerLumen<num_complex::Complex64>> for &num_complex::Complex64 {
170	type Output = AreaPerLumen<num_complex::Complex64>;
171	fn mul(self, rhs: &AreaPerLumen<num_complex::Complex64>) -> Self::Output {
172		AreaPerLumen{m2_per_lm: self.clone() * rhs.m2_per_lm.clone()}
173	}
174}
175
176
177
178
179// AreaPerLumen / InverseLuminousFlux -> Area
180/// Dividing a AreaPerLumen by a InverseLuminousFlux returns a value of type Area
181impl<T> core::ops::Div<InverseLuminousFlux<T>> for AreaPerLumen<T> where T: NumLike {
182	type Output = Area<T>;
183	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
184		Area{m2: self.m2_per_lm / rhs.per_lm}
185	}
186}
187/// Dividing a AreaPerLumen by a InverseLuminousFlux returns a value of type Area
188impl<T> core::ops::Div<InverseLuminousFlux<T>> for &AreaPerLumen<T> where T: NumLike {
189	type Output = Area<T>;
190	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
191		Area{m2: self.m2_per_lm.clone() / rhs.per_lm}
192	}
193}
194/// Dividing a AreaPerLumen by a InverseLuminousFlux returns a value of type Area
195impl<T> core::ops::Div<&InverseLuminousFlux<T>> for AreaPerLumen<T> where T: NumLike {
196	type Output = Area<T>;
197	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
198		Area{m2: self.m2_per_lm / rhs.per_lm.clone()}
199	}
200}
201/// Dividing a AreaPerLumen by a InverseLuminousFlux returns a value of type Area
202impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &AreaPerLumen<T> where T: NumLike {
203	type Output = Area<T>;
204	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
205		Area{m2: self.m2_per_lm.clone() / rhs.per_lm.clone()}
206	}
207}
208
209// AreaPerLumen * LuminousFlux -> Area
210/// Multiplying a AreaPerLumen by a LuminousFlux returns a value of type Area
211impl<T> core::ops::Mul<LuminousFlux<T>> for AreaPerLumen<T> where T: NumLike {
212	type Output = Area<T>;
213	fn mul(self, rhs: LuminousFlux<T>) -> Self::Output {
214		Area{m2: self.m2_per_lm * rhs.lm}
215	}
216}
217/// Multiplying a AreaPerLumen by a LuminousFlux returns a value of type Area
218impl<T> core::ops::Mul<LuminousFlux<T>> for &AreaPerLumen<T> where T: NumLike {
219	type Output = Area<T>;
220	fn mul(self, rhs: LuminousFlux<T>) -> Self::Output {
221		Area{m2: self.m2_per_lm.clone() * rhs.lm}
222	}
223}
224/// Multiplying a AreaPerLumen by a LuminousFlux returns a value of type Area
225impl<T> core::ops::Mul<&LuminousFlux<T>> for AreaPerLumen<T> where T: NumLike {
226	type Output = Area<T>;
227	fn mul(self, rhs: &LuminousFlux<T>) -> Self::Output {
228		Area{m2: self.m2_per_lm * rhs.lm.clone()}
229	}
230}
231/// Multiplying a AreaPerLumen by a LuminousFlux returns a value of type Area
232impl<T> core::ops::Mul<&LuminousFlux<T>> for &AreaPerLumen<T> where T: NumLike {
233	type Output = Area<T>;
234	fn mul(self, rhs: &LuminousFlux<T>) -> Self::Output {
235		Area{m2: self.m2_per_lm.clone() * rhs.lm.clone()}
236	}
237}
238
239// AreaPerLumen / Area -> InverseLuminousFlux
240/// Dividing a AreaPerLumen by a Area returns a value of type InverseLuminousFlux
241impl<T> core::ops::Div<Area<T>> for AreaPerLumen<T> where T: NumLike {
242	type Output = InverseLuminousFlux<T>;
243	fn div(self, rhs: Area<T>) -> Self::Output {
244		InverseLuminousFlux{per_lm: self.m2_per_lm / rhs.m2}
245	}
246}
247/// Dividing a AreaPerLumen by a Area returns a value of type InverseLuminousFlux
248impl<T> core::ops::Div<Area<T>> for &AreaPerLumen<T> where T: NumLike {
249	type Output = InverseLuminousFlux<T>;
250	fn div(self, rhs: Area<T>) -> Self::Output {
251		InverseLuminousFlux{per_lm: self.m2_per_lm.clone() / rhs.m2}
252	}
253}
254/// Dividing a AreaPerLumen by a Area returns a value of type InverseLuminousFlux
255impl<T> core::ops::Div<&Area<T>> for AreaPerLumen<T> where T: NumLike {
256	type Output = InverseLuminousFlux<T>;
257	fn div(self, rhs: &Area<T>) -> Self::Output {
258		InverseLuminousFlux{per_lm: self.m2_per_lm / rhs.m2.clone()}
259	}
260}
261/// Dividing a AreaPerLumen by a Area returns a value of type InverseLuminousFlux
262impl<T> core::ops::Div<&Area<T>> for &AreaPerLumen<T> where T: NumLike {
263	type Output = InverseLuminousFlux<T>;
264	fn div(self, rhs: &Area<T>) -> Self::Output {
265		InverseLuminousFlux{per_lm: self.m2_per_lm.clone() / rhs.m2.clone()}
266	}
267}
268
269// AreaPerLumen * InverseArea -> InverseLuminousFlux
270/// Multiplying a AreaPerLumen by a InverseArea returns a value of type InverseLuminousFlux
271impl<T> core::ops::Mul<InverseArea<T>> for AreaPerLumen<T> where T: NumLike {
272	type Output = InverseLuminousFlux<T>;
273	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
274		InverseLuminousFlux{per_lm: self.m2_per_lm * rhs.per_m2}
275	}
276}
277/// Multiplying a AreaPerLumen by a InverseArea returns a value of type InverseLuminousFlux
278impl<T> core::ops::Mul<InverseArea<T>> for &AreaPerLumen<T> where T: NumLike {
279	type Output = InverseLuminousFlux<T>;
280	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
281		InverseLuminousFlux{per_lm: self.m2_per_lm.clone() * rhs.per_m2}
282	}
283}
284/// Multiplying a AreaPerLumen by a InverseArea returns a value of type InverseLuminousFlux
285impl<T> core::ops::Mul<&InverseArea<T>> for AreaPerLumen<T> where T: NumLike {
286	type Output = InverseLuminousFlux<T>;
287	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
288		InverseLuminousFlux{per_lm: self.m2_per_lm * rhs.per_m2.clone()}
289	}
290}
291/// Multiplying a AreaPerLumen by a InverseArea returns a value of type InverseLuminousFlux
292impl<T> core::ops::Mul<&InverseArea<T>> for &AreaPerLumen<T> where T: NumLike {
293	type Output = InverseLuminousFlux<T>;
294	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
295		InverseLuminousFlux{per_lm: self.m2_per_lm.clone() * rhs.per_m2.clone()}
296	}
297}
298
299// 1/AreaPerLumen -> Illuminance
300/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
301impl<T> core::ops::Div<AreaPerLumen<T>> for f64 where T: NumLike+From<f64> {
302	type Output = Illuminance<T>;
303	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
304		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
305	}
306}
307/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
308impl<T> core::ops::Div<AreaPerLumen<T>> for &f64 where T: NumLike+From<f64> {
309	type Output = Illuminance<T>;
310	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
311		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
312	}
313}
314/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
315impl<T> core::ops::Div<&AreaPerLumen<T>> for f64 where T: NumLike+From<f64> {
316	type Output = Illuminance<T>;
317	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
318		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
319	}
320}
321/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
322impl<T> core::ops::Div<&AreaPerLumen<T>> for &f64 where T: NumLike+From<f64> {
323	type Output = Illuminance<T>;
324	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
325		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
326	}
327}
328
329// 1/AreaPerLumen -> Illuminance
330/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
331impl<T> core::ops::Div<AreaPerLumen<T>> for f32 where T: NumLike+From<f32> {
332	type Output = Illuminance<T>;
333	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
334		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
335	}
336}
337/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
338impl<T> core::ops::Div<AreaPerLumen<T>> for &f32 where T: NumLike+From<f32> {
339	type Output = Illuminance<T>;
340	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
341		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
342	}
343}
344/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
345impl<T> core::ops::Div<&AreaPerLumen<T>> for f32 where T: NumLike+From<f32> {
346	type Output = Illuminance<T>;
347	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
348		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
349	}
350}
351/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
352impl<T> core::ops::Div<&AreaPerLumen<T>> for &f32 where T: NumLike+From<f32> {
353	type Output = Illuminance<T>;
354	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
355		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
356	}
357}
358
359// 1/AreaPerLumen -> Illuminance
360/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
361impl<T> core::ops::Div<AreaPerLumen<T>> for i64 where T: NumLike+From<i64> {
362	type Output = Illuminance<T>;
363	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
364		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
365	}
366}
367/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
368impl<T> core::ops::Div<AreaPerLumen<T>> for &i64 where T: NumLike+From<i64> {
369	type Output = Illuminance<T>;
370	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
371		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
372	}
373}
374/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
375impl<T> core::ops::Div<&AreaPerLumen<T>> for i64 where T: NumLike+From<i64> {
376	type Output = Illuminance<T>;
377	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
378		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
379	}
380}
381/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
382impl<T> core::ops::Div<&AreaPerLumen<T>> for &i64 where T: NumLike+From<i64> {
383	type Output = Illuminance<T>;
384	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
385		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
386	}
387}
388
389// 1/AreaPerLumen -> Illuminance
390/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
391impl<T> core::ops::Div<AreaPerLumen<T>> for i32 where T: NumLike+From<i32> {
392	type Output = Illuminance<T>;
393	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
394		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
395	}
396}
397/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
398impl<T> core::ops::Div<AreaPerLumen<T>> for &i32 where T: NumLike+From<i32> {
399	type Output = Illuminance<T>;
400	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
401		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
402	}
403}
404/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
405impl<T> core::ops::Div<&AreaPerLumen<T>> for i32 where T: NumLike+From<i32> {
406	type Output = Illuminance<T>;
407	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
408		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
409	}
410}
411/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
412impl<T> core::ops::Div<&AreaPerLumen<T>> for &i32 where T: NumLike+From<i32> {
413	type Output = Illuminance<T>;
414	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
415		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
416	}
417}
418
419// 1/AreaPerLumen -> Illuminance
420/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
421#[cfg(feature="num-bigfloat")]
422impl<T> core::ops::Div<AreaPerLumen<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
423	type Output = Illuminance<T>;
424	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
425		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
426	}
427}
428/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
429#[cfg(feature="num-bigfloat")]
430impl<T> core::ops::Div<AreaPerLumen<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
431	type Output = Illuminance<T>;
432	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
433		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
434	}
435}
436/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
437#[cfg(feature="num-bigfloat")]
438impl<T> core::ops::Div<&AreaPerLumen<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
439	type Output = Illuminance<T>;
440	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
441		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
442	}
443}
444/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
445#[cfg(feature="num-bigfloat")]
446impl<T> core::ops::Div<&AreaPerLumen<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
447	type Output = Illuminance<T>;
448	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
449		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
450	}
451}
452
453// 1/AreaPerLumen -> Illuminance
454/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
455#[cfg(feature="num-complex")]
456impl<T> core::ops::Div<AreaPerLumen<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
457	type Output = Illuminance<T>;
458	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
459		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
460	}
461}
462/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
463#[cfg(feature="num-complex")]
464impl<T> core::ops::Div<AreaPerLumen<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
465	type Output = Illuminance<T>;
466	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
467		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
468	}
469}
470/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
471#[cfg(feature="num-complex")]
472impl<T> core::ops::Div<&AreaPerLumen<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
473	type Output = Illuminance<T>;
474	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
475		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
476	}
477}
478/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
479#[cfg(feature="num-complex")]
480impl<T> core::ops::Div<&AreaPerLumen<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
481	type Output = Illuminance<T>;
482	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
483		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
484	}
485}
486
487// 1/AreaPerLumen -> Illuminance
488/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
489#[cfg(feature="num-complex")]
490impl<T> core::ops::Div<AreaPerLumen<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
491	type Output = Illuminance<T>;
492	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
493		Illuminance{lux: T::from(self) / rhs.m2_per_lm}
494	}
495}
496/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
497#[cfg(feature="num-complex")]
498impl<T> core::ops::Div<AreaPerLumen<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
499	type Output = Illuminance<T>;
500	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
501		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm}
502	}
503}
504/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
505#[cfg(feature="num-complex")]
506impl<T> core::ops::Div<&AreaPerLumen<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
507	type Output = Illuminance<T>;
508	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
509		Illuminance{lux: T::from(self) / rhs.m2_per_lm.clone()}
510	}
511}
512/// Dividing a scalar value by a AreaPerLumen unit value returns a value of type Illuminance
513#[cfg(feature="num-complex")]
514impl<T> core::ops::Div<&AreaPerLumen<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
515	type Output = Illuminance<T>;
516	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
517		Illuminance{lux: T::from(self.clone()) / rhs.m2_per_lm.clone()}
518	}
519}
520
521/// The electrical capacitance unit type, defined as farads in SI units
522#[derive(UnitStruct, Debug, Clone)]
523#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
524pub struct Capacitance<T: NumLike>{
525	/// The value of this Electrical capacitance in farads
526	pub F: T
527}
528
529impl<T> Capacitance<T> where T: NumLike {
530
531	/// Returns the standard unit name of electrical capacitance: "farads"
532	pub fn unit_name() -> &'static str { "farads" }
533	
534	/// Returns the abbreviated name or symbol of electrical capacitance: "F" for farads
535	pub fn unit_symbol() -> &'static str { "F" }
536	
537	/// Returns a new electrical capacitance value from the given number of farads
538	///
539	/// # Arguments
540	/// * `F` - Any number-like type, representing a quantity of farads
541	pub fn from_F(F: T) -> Self { Capacitance{F: F} }
542	
543	/// Returns a copy of this electrical capacitance value in farads
544	pub fn to_F(&self) -> T { self.F.clone() }
545
546	/// Returns a new electrical capacitance value from the given number of farads
547	///
548	/// # Arguments
549	/// * `farads` - Any number-like type, representing a quantity of farads
550	pub fn from_farads(farads: T) -> Self { Capacitance{F: farads} }
551	
552	/// Returns a copy of this electrical capacitance value in farads
553	pub fn to_farads(&self) -> T { self.F.clone() }
554
555}
556
557impl<T> fmt::Display for Capacitance<T> where T: NumLike {
558	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
559		write!(f, "{} {}", &self.F, Self::unit_symbol())
560	}
561}
562
563impl<T> Capacitance<T> where T: NumLike+From<f64> {
564	
565	/// Returns a copy of this electrical capacitance value in millifarads
566	/// 
567	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
568	pub fn to_mF(&self) -> T {
569		return self.F.clone() * T::from(1000.0_f64);
570	}
571
572	/// Returns a new electrical capacitance value from the given number of millifarads
573	/// 
574	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
575	///
576	/// # Arguments
577	/// * `mF` - Any number-like type, representing a quantity of millifarads
578	pub fn from_mF(mF: T) -> Self {
579		Capacitance{F: mF * T::from(0.001_f64)}
580	}
581
582	/// Returns a copy of this electrical capacitance value in microfarads
583	/// 
584	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
585	pub fn to_uF(&self) -> T {
586		return self.F.clone() * T::from(1000000.0_f64);
587	}
588
589	/// Returns a new electrical capacitance value from the given number of microfarads
590	/// 
591	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
592	///
593	/// # Arguments
594	/// * `uF` - Any number-like type, representing a quantity of microfarads
595	pub fn from_uF(uF: T) -> Self {
596		Capacitance{F: uF * T::from(1e-06_f64)}
597	}
598
599	/// Returns a copy of this electrical capacitance value in nanofarads
600	/// 
601	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
602	pub fn to_nF(&self) -> T {
603		return self.F.clone() * T::from(1000000000.0_f64);
604	}
605
606	/// Returns a new electrical capacitance value from the given number of nanofarads
607	/// 
608	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
609	///
610	/// # Arguments
611	/// * `nF` - Any number-like type, representing a quantity of nanofarads
612	pub fn from_nF(nF: T) -> Self {
613		Capacitance{F: nF * T::from(1e-09_f64)}
614	}
615
616	/// Returns a copy of this electrical capacitance value in picofarads
617	/// 
618	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
619	pub fn to_pF(&self) -> T {
620		return self.F.clone() * T::from(1000000000000.0_f64);
621	}
622
623	/// Returns a new electrical capacitance value from the given number of picofarads
624	/// 
625	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
626	///
627	/// # Arguments
628	/// * `pF` - Any number-like type, representing a quantity of picofarads
629	pub fn from_pF(pF: T) -> Self {
630		Capacitance{F: pF * T::from(1e-12_f64)}
631	}
632
633	/// Returns a copy of this electrical capacitance value in kilofarads
634	/// 
635	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
636	pub fn to_kF(&self) -> T {
637		return self.F.clone() * T::from(0.001_f64);
638	}
639
640	/// Returns a new electrical capacitance value from the given number of kilofarads
641	/// 
642	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
643	///
644	/// # Arguments
645	/// * `kF` - Any number-like type, representing a quantity of kilofarads
646	pub fn from_kF(kF: T) -> Self {
647		Capacitance{F: kF * T::from(1000.0_f64)}
648	}
649
650	/// Returns a copy of this electrical capacitance value in megafarads
651	/// 
652	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
653	pub fn to_MF(&self) -> T {
654		return self.F.clone() * T::from(1e-06_f64);
655	}
656
657	/// Returns a new electrical capacitance value from the given number of megafarads
658	/// 
659	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
660	///
661	/// # Arguments
662	/// * `MF` - Any number-like type, representing a quantity of megafarads
663	pub fn from_MF(MF: T) -> Self {
664		Capacitance{F: MF * T::from(1000000.0_f64)}
665	}
666
667	/// Returns a copy of this electrical capacitance value in gigafarads
668	/// 
669	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
670	pub fn to_GF(&self) -> T {
671		return self.F.clone() * T::from(1e-09_f64);
672	}
673
674	/// Returns a new electrical capacitance value from the given number of gigafarads
675	/// 
676	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
677	///
678	/// # Arguments
679	/// * `GF` - Any number-like type, representing a quantity of gigafarads
680	pub fn from_GF(GF: T) -> Self {
681		Capacitance{F: GF * T::from(1000000000.0_f64)}
682	}
683
684}
685
686
687/// Multiplying a unit value by a scalar value returns a unit value
688#[cfg(feature="num-bigfloat")]
689impl core::ops::Mul<Capacitance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
690	type Output = Capacitance<num_bigfloat::BigFloat>;
691	fn mul(self, rhs: Capacitance<num_bigfloat::BigFloat>) -> Self::Output {
692		Capacitance{F: self * rhs.F}
693	}
694}
695/// Multiplying a unit value by a scalar value returns a unit value
696#[cfg(feature="num-bigfloat")]
697impl core::ops::Mul<Capacitance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
698	type Output = Capacitance<num_bigfloat::BigFloat>;
699	fn mul(self, rhs: Capacitance<num_bigfloat::BigFloat>) -> Self::Output {
700		Capacitance{F: self.clone() * rhs.F}
701	}
702}
703/// Multiplying a unit value by a scalar value returns a unit value
704#[cfg(feature="num-bigfloat")]
705impl core::ops::Mul<&Capacitance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
706	type Output = Capacitance<num_bigfloat::BigFloat>;
707	fn mul(self, rhs: &Capacitance<num_bigfloat::BigFloat>) -> Self::Output {
708		Capacitance{F: self * rhs.F.clone()}
709	}
710}
711/// Multiplying a unit value by a scalar value returns a unit value
712#[cfg(feature="num-bigfloat")]
713impl core::ops::Mul<&Capacitance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
714	type Output = Capacitance<num_bigfloat::BigFloat>;
715	fn mul(self, rhs: &Capacitance<num_bigfloat::BigFloat>) -> Self::Output {
716		Capacitance{F: self.clone() * rhs.F.clone()}
717	}
718}
719
720/// Multiplying a unit value by a scalar value returns a unit value
721#[cfg(feature="num-complex")]
722impl core::ops::Mul<Capacitance<num_complex::Complex32>> for num_complex::Complex32 {
723	type Output = Capacitance<num_complex::Complex32>;
724	fn mul(self, rhs: Capacitance<num_complex::Complex32>) -> Self::Output {
725		Capacitance{F: self * rhs.F}
726	}
727}
728/// Multiplying a unit value by a scalar value returns a unit value
729#[cfg(feature="num-complex")]
730impl core::ops::Mul<Capacitance<num_complex::Complex32>> for &num_complex::Complex32 {
731	type Output = Capacitance<num_complex::Complex32>;
732	fn mul(self, rhs: Capacitance<num_complex::Complex32>) -> Self::Output {
733		Capacitance{F: self.clone() * rhs.F}
734	}
735}
736/// Multiplying a unit value by a scalar value returns a unit value
737#[cfg(feature="num-complex")]
738impl core::ops::Mul<&Capacitance<num_complex::Complex32>> for num_complex::Complex32 {
739	type Output = Capacitance<num_complex::Complex32>;
740	fn mul(self, rhs: &Capacitance<num_complex::Complex32>) -> Self::Output {
741		Capacitance{F: self * rhs.F.clone()}
742	}
743}
744/// Multiplying a unit value by a scalar value returns a unit value
745#[cfg(feature="num-complex")]
746impl core::ops::Mul<&Capacitance<num_complex::Complex32>> for &num_complex::Complex32 {
747	type Output = Capacitance<num_complex::Complex32>;
748	fn mul(self, rhs: &Capacitance<num_complex::Complex32>) -> Self::Output {
749		Capacitance{F: self.clone() * rhs.F.clone()}
750	}
751}
752
753/// Multiplying a unit value by a scalar value returns a unit value
754#[cfg(feature="num-complex")]
755impl core::ops::Mul<Capacitance<num_complex::Complex64>> for num_complex::Complex64 {
756	type Output = Capacitance<num_complex::Complex64>;
757	fn mul(self, rhs: Capacitance<num_complex::Complex64>) -> Self::Output {
758		Capacitance{F: self * rhs.F}
759	}
760}
761/// Multiplying a unit value by a scalar value returns a unit value
762#[cfg(feature="num-complex")]
763impl core::ops::Mul<Capacitance<num_complex::Complex64>> for &num_complex::Complex64 {
764	type Output = Capacitance<num_complex::Complex64>;
765	fn mul(self, rhs: Capacitance<num_complex::Complex64>) -> Self::Output {
766		Capacitance{F: self.clone() * rhs.F}
767	}
768}
769/// Multiplying a unit value by a scalar value returns a unit value
770#[cfg(feature="num-complex")]
771impl core::ops::Mul<&Capacitance<num_complex::Complex64>> for num_complex::Complex64 {
772	type Output = Capacitance<num_complex::Complex64>;
773	fn mul(self, rhs: &Capacitance<num_complex::Complex64>) -> Self::Output {
774		Capacitance{F: self * rhs.F.clone()}
775	}
776}
777/// Multiplying a unit value by a scalar value returns a unit value
778#[cfg(feature="num-complex")]
779impl core::ops::Mul<&Capacitance<num_complex::Complex64>> for &num_complex::Complex64 {
780	type Output = Capacitance<num_complex::Complex64>;
781	fn mul(self, rhs: &Capacitance<num_complex::Complex64>) -> Self::Output {
782		Capacitance{F: self.clone() * rhs.F.clone()}
783	}
784}
785
786
787
788/// Converts a Capacitance into the equivalent [uom](https://crates.io/crates/uom) type [Capacitance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Capacitance.html)
789#[cfg(feature = "uom")]
790impl<T> Into<uom::si::f32::Capacitance> for Capacitance<T> where T: NumLike+Into<f32> {
791	fn into(self) -> uom::si::f32::Capacitance {
792		uom::si::f32::Capacitance::new::<uom::si::capacitance::farad>(self.F.into())
793	}
794}
795
796/// Creates a Capacitance from the equivalent [uom](https://crates.io/crates/uom) type [Capacitance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Capacitance.html)
797#[cfg(feature = "uom")]
798impl<T> From<uom::si::f32::Capacitance> for Capacitance<T> where T: NumLike+From<f32> {
799	fn from(src: uom::si::f32::Capacitance) -> Self {
800		Capacitance{F: T::from(src.value)}
801	}
802}
803
804/// Converts a Capacitance into the equivalent [uom](https://crates.io/crates/uom) type [Capacitance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Capacitance.html)
805#[cfg(feature = "uom")]
806impl<T> Into<uom::si::f64::Capacitance> for Capacitance<T> where T: NumLike+Into<f64> {
807	fn into(self) -> uom::si::f64::Capacitance {
808		uom::si::f64::Capacitance::new::<uom::si::capacitance::farad>(self.F.into())
809	}
810}
811
812/// Creates a Capacitance from the equivalent [uom](https://crates.io/crates/uom) type [Capacitance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Capacitance.html)
813#[cfg(feature = "uom")]
814impl<T> From<uom::si::f64::Capacitance> for Capacitance<T> where T: NumLike+From<f64> {
815	fn from(src: uom::si::f64::Capacitance) -> Self {
816		Capacitance{F: T::from(src.value)}
817	}
818}
819
820
821// Capacitance / Time -> Conductance
822/// Dividing a Capacitance by a Time returns a value of type Conductance
823impl<T> core::ops::Div<Time<T>> for Capacitance<T> where T: NumLike {
824	type Output = Conductance<T>;
825	fn div(self, rhs: Time<T>) -> Self::Output {
826		Conductance{S: self.F / rhs.s}
827	}
828}
829/// Dividing a Capacitance by a Time returns a value of type Conductance
830impl<T> core::ops::Div<Time<T>> for &Capacitance<T> where T: NumLike {
831	type Output = Conductance<T>;
832	fn div(self, rhs: Time<T>) -> Self::Output {
833		Conductance{S: self.F.clone() / rhs.s}
834	}
835}
836/// Dividing a Capacitance by a Time returns a value of type Conductance
837impl<T> core::ops::Div<&Time<T>> for Capacitance<T> where T: NumLike {
838	type Output = Conductance<T>;
839	fn div(self, rhs: &Time<T>) -> Self::Output {
840		Conductance{S: self.F / rhs.s.clone()}
841	}
842}
843/// Dividing a Capacitance by a Time returns a value of type Conductance
844impl<T> core::ops::Div<&Time<T>> for &Capacitance<T> where T: NumLike {
845	type Output = Conductance<T>;
846	fn div(self, rhs: &Time<T>) -> Self::Output {
847		Conductance{S: self.F.clone() / rhs.s.clone()}
848	}
849}
850
851// Capacitance / Charge -> InverseVoltage
852/// Dividing a Capacitance by a Charge returns a value of type InverseVoltage
853impl<T> core::ops::Div<Charge<T>> for Capacitance<T> where T: NumLike {
854	type Output = InverseVoltage<T>;
855	fn div(self, rhs: Charge<T>) -> Self::Output {
856		InverseVoltage{per_V: self.F / rhs.C}
857	}
858}
859/// Dividing a Capacitance by a Charge returns a value of type InverseVoltage
860impl<T> core::ops::Div<Charge<T>> for &Capacitance<T> where T: NumLike {
861	type Output = InverseVoltage<T>;
862	fn div(self, rhs: Charge<T>) -> Self::Output {
863		InverseVoltage{per_V: self.F.clone() / rhs.C}
864	}
865}
866/// Dividing a Capacitance by a Charge returns a value of type InverseVoltage
867impl<T> core::ops::Div<&Charge<T>> for Capacitance<T> where T: NumLike {
868	type Output = InverseVoltage<T>;
869	fn div(self, rhs: &Charge<T>) -> Self::Output {
870		InverseVoltage{per_V: self.F / rhs.C.clone()}
871	}
872}
873/// Dividing a Capacitance by a Charge returns a value of type InverseVoltage
874impl<T> core::ops::Div<&Charge<T>> for &Capacitance<T> where T: NumLike {
875	type Output = InverseVoltage<T>;
876	fn div(self, rhs: &Charge<T>) -> Self::Output {
877		InverseVoltage{per_V: self.F.clone() / rhs.C.clone()}
878	}
879}
880
881// Capacitance / Conductance -> Time
882/// Dividing a Capacitance by a Conductance returns a value of type Time
883impl<T> core::ops::Div<Conductance<T>> for Capacitance<T> where T: NumLike {
884	type Output = Time<T>;
885	fn div(self, rhs: Conductance<T>) -> Self::Output {
886		Time{s: self.F / rhs.S}
887	}
888}
889/// Dividing a Capacitance by a Conductance returns a value of type Time
890impl<T> core::ops::Div<Conductance<T>> for &Capacitance<T> where T: NumLike {
891	type Output = Time<T>;
892	fn div(self, rhs: Conductance<T>) -> Self::Output {
893		Time{s: self.F.clone() / rhs.S}
894	}
895}
896/// Dividing a Capacitance by a Conductance returns a value of type Time
897impl<T> core::ops::Div<&Conductance<T>> for Capacitance<T> where T: NumLike {
898	type Output = Time<T>;
899	fn div(self, rhs: &Conductance<T>) -> Self::Output {
900		Time{s: self.F / rhs.S.clone()}
901	}
902}
903/// Dividing a Capacitance by a Conductance returns a value of type Time
904impl<T> core::ops::Div<&Conductance<T>> for &Capacitance<T> where T: NumLike {
905	type Output = Time<T>;
906	fn div(self, rhs: &Conductance<T>) -> Self::Output {
907		Time{s: self.F.clone() / rhs.S.clone()}
908	}
909}
910
911// Capacitance * InverseCharge -> InverseVoltage
912/// Multiplying a Capacitance by a InverseCharge returns a value of type InverseVoltage
913impl<T> core::ops::Mul<InverseCharge<T>> for Capacitance<T> where T: NumLike {
914	type Output = InverseVoltage<T>;
915	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
916		InverseVoltage{per_V: self.F * rhs.per_C}
917	}
918}
919/// Multiplying a Capacitance by a InverseCharge returns a value of type InverseVoltage
920impl<T> core::ops::Mul<InverseCharge<T>> for &Capacitance<T> where T: NumLike {
921	type Output = InverseVoltage<T>;
922	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
923		InverseVoltage{per_V: self.F.clone() * rhs.per_C}
924	}
925}
926/// Multiplying a Capacitance by a InverseCharge returns a value of type InverseVoltage
927impl<T> core::ops::Mul<&InverseCharge<T>> for Capacitance<T> where T: NumLike {
928	type Output = InverseVoltage<T>;
929	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
930		InverseVoltage{per_V: self.F * rhs.per_C.clone()}
931	}
932}
933/// Multiplying a Capacitance by a InverseCharge returns a value of type InverseVoltage
934impl<T> core::ops::Mul<&InverseCharge<T>> for &Capacitance<T> where T: NumLike {
935	type Output = InverseVoltage<T>;
936	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
937		InverseVoltage{per_V: self.F.clone() * rhs.per_C.clone()}
938	}
939}
940
941// Capacitance / InverseVoltage -> Charge
942/// Dividing a Capacitance by a InverseVoltage returns a value of type Charge
943impl<T> core::ops::Div<InverseVoltage<T>> for Capacitance<T> where T: NumLike {
944	type Output = Charge<T>;
945	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
946		Charge{C: self.F / rhs.per_V}
947	}
948}
949/// Dividing a Capacitance by a InverseVoltage returns a value of type Charge
950impl<T> core::ops::Div<InverseVoltage<T>> for &Capacitance<T> where T: NumLike {
951	type Output = Charge<T>;
952	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
953		Charge{C: self.F.clone() / rhs.per_V}
954	}
955}
956/// Dividing a Capacitance by a InverseVoltage returns a value of type Charge
957impl<T> core::ops::Div<&InverseVoltage<T>> for Capacitance<T> where T: NumLike {
958	type Output = Charge<T>;
959	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
960		Charge{C: self.F / rhs.per_V.clone()}
961	}
962}
963/// Dividing a Capacitance by a InverseVoltage returns a value of type Charge
964impl<T> core::ops::Div<&InverseVoltage<T>> for &Capacitance<T> where T: NumLike {
965	type Output = Charge<T>;
966	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
967		Charge{C: self.F.clone() / rhs.per_V.clone()}
968	}
969}
970
971// Capacitance * Resistance -> Time
972/// Multiplying a Capacitance by a Resistance returns a value of type Time
973impl<T> core::ops::Mul<Resistance<T>> for Capacitance<T> where T: NumLike {
974	type Output = Time<T>;
975	fn mul(self, rhs: Resistance<T>) -> Self::Output {
976		Time{s: self.F * rhs.Ohm}
977	}
978}
979/// Multiplying a Capacitance by a Resistance returns a value of type Time
980impl<T> core::ops::Mul<Resistance<T>> for &Capacitance<T> where T: NumLike {
981	type Output = Time<T>;
982	fn mul(self, rhs: Resistance<T>) -> Self::Output {
983		Time{s: self.F.clone() * rhs.Ohm}
984	}
985}
986/// Multiplying a Capacitance by a Resistance returns a value of type Time
987impl<T> core::ops::Mul<&Resistance<T>> for Capacitance<T> where T: NumLike {
988	type Output = Time<T>;
989	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
990		Time{s: self.F * rhs.Ohm.clone()}
991	}
992}
993/// Multiplying a Capacitance by a Resistance returns a value of type Time
994impl<T> core::ops::Mul<&Resistance<T>> for &Capacitance<T> where T: NumLike {
995	type Output = Time<T>;
996	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
997		Time{s: self.F.clone() * rhs.Ohm.clone()}
998	}
999}
1000
1001// Capacitance * Voltage -> Charge
1002/// Multiplying a Capacitance by a Voltage returns a value of type Charge
1003impl<T> core::ops::Mul<Voltage<T>> for Capacitance<T> where T: NumLike {
1004	type Output = Charge<T>;
1005	fn mul(self, rhs: Voltage<T>) -> Self::Output {
1006		Charge{C: self.F * rhs.V}
1007	}
1008}
1009/// Multiplying a Capacitance by a Voltage returns a value of type Charge
1010impl<T> core::ops::Mul<Voltage<T>> for &Capacitance<T> where T: NumLike {
1011	type Output = Charge<T>;
1012	fn mul(self, rhs: Voltage<T>) -> Self::Output {
1013		Charge{C: self.F.clone() * rhs.V}
1014	}
1015}
1016/// Multiplying a Capacitance by a Voltage returns a value of type Charge
1017impl<T> core::ops::Mul<&Voltage<T>> for Capacitance<T> where T: NumLike {
1018	type Output = Charge<T>;
1019	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
1020		Charge{C: self.F * rhs.V.clone()}
1021	}
1022}
1023/// Multiplying a Capacitance by a Voltage returns a value of type Charge
1024impl<T> core::ops::Mul<&Voltage<T>> for &Capacitance<T> where T: NumLike {
1025	type Output = Charge<T>;
1026	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
1027		Charge{C: self.F.clone() * rhs.V.clone()}
1028	}
1029}
1030
1031// Capacitance * Frequency -> Conductance
1032/// Multiplying a Capacitance by a Frequency returns a value of type Conductance
1033impl<T> core::ops::Mul<Frequency<T>> for Capacitance<T> where T: NumLike {
1034	type Output = Conductance<T>;
1035	fn mul(self, rhs: Frequency<T>) -> Self::Output {
1036		Conductance{S: self.F * rhs.Hz}
1037	}
1038}
1039/// Multiplying a Capacitance by a Frequency returns a value of type Conductance
1040impl<T> core::ops::Mul<Frequency<T>> for &Capacitance<T> where T: NumLike {
1041	type Output = Conductance<T>;
1042	fn mul(self, rhs: Frequency<T>) -> Self::Output {
1043		Conductance{S: self.F.clone() * rhs.Hz}
1044	}
1045}
1046/// Multiplying a Capacitance by a Frequency returns a value of type Conductance
1047impl<T> core::ops::Mul<&Frequency<T>> for Capacitance<T> where T: NumLike {
1048	type Output = Conductance<T>;
1049	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
1050		Conductance{S: self.F * rhs.Hz.clone()}
1051	}
1052}
1053/// Multiplying a Capacitance by a Frequency returns a value of type Conductance
1054impl<T> core::ops::Mul<&Frequency<T>> for &Capacitance<T> where T: NumLike {
1055	type Output = Conductance<T>;
1056	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
1057		Conductance{S: self.F.clone() * rhs.Hz.clone()}
1058	}
1059}
1060
1061// 1/Capacitance -> Elastance
1062/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1063impl<T> core::ops::Div<Capacitance<T>> for f64 where T: NumLike+From<f64> {
1064	type Output = Elastance<T>;
1065	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1066		Elastance{per_F: T::from(self) / rhs.F}
1067	}
1068}
1069/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1070impl<T> core::ops::Div<Capacitance<T>> for &f64 where T: NumLike+From<f64> {
1071	type Output = Elastance<T>;
1072	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1073		Elastance{per_F: T::from(self.clone()) / rhs.F}
1074	}
1075}
1076/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1077impl<T> core::ops::Div<&Capacitance<T>> for f64 where T: NumLike+From<f64> {
1078	type Output = Elastance<T>;
1079	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1080		Elastance{per_F: T::from(self) / rhs.F.clone()}
1081	}
1082}
1083/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1084impl<T> core::ops::Div<&Capacitance<T>> for &f64 where T: NumLike+From<f64> {
1085	type Output = Elastance<T>;
1086	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1087		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1088	}
1089}
1090
1091// 1/Capacitance -> Elastance
1092/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1093impl<T> core::ops::Div<Capacitance<T>> for f32 where T: NumLike+From<f32> {
1094	type Output = Elastance<T>;
1095	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1096		Elastance{per_F: T::from(self) / rhs.F}
1097	}
1098}
1099/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1100impl<T> core::ops::Div<Capacitance<T>> for &f32 where T: NumLike+From<f32> {
1101	type Output = Elastance<T>;
1102	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1103		Elastance{per_F: T::from(self.clone()) / rhs.F}
1104	}
1105}
1106/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1107impl<T> core::ops::Div<&Capacitance<T>> for f32 where T: NumLike+From<f32> {
1108	type Output = Elastance<T>;
1109	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1110		Elastance{per_F: T::from(self) / rhs.F.clone()}
1111	}
1112}
1113/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1114impl<T> core::ops::Div<&Capacitance<T>> for &f32 where T: NumLike+From<f32> {
1115	type Output = Elastance<T>;
1116	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1117		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1118	}
1119}
1120
1121// 1/Capacitance -> Elastance
1122/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1123impl<T> core::ops::Div<Capacitance<T>> for i64 where T: NumLike+From<i64> {
1124	type Output = Elastance<T>;
1125	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1126		Elastance{per_F: T::from(self) / rhs.F}
1127	}
1128}
1129/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1130impl<T> core::ops::Div<Capacitance<T>> for &i64 where T: NumLike+From<i64> {
1131	type Output = Elastance<T>;
1132	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1133		Elastance{per_F: T::from(self.clone()) / rhs.F}
1134	}
1135}
1136/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1137impl<T> core::ops::Div<&Capacitance<T>> for i64 where T: NumLike+From<i64> {
1138	type Output = Elastance<T>;
1139	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1140		Elastance{per_F: T::from(self) / rhs.F.clone()}
1141	}
1142}
1143/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1144impl<T> core::ops::Div<&Capacitance<T>> for &i64 where T: NumLike+From<i64> {
1145	type Output = Elastance<T>;
1146	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1147		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1148	}
1149}
1150
1151// 1/Capacitance -> Elastance
1152/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1153impl<T> core::ops::Div<Capacitance<T>> for i32 where T: NumLike+From<i32> {
1154	type Output = Elastance<T>;
1155	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1156		Elastance{per_F: T::from(self) / rhs.F}
1157	}
1158}
1159/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1160impl<T> core::ops::Div<Capacitance<T>> for &i32 where T: NumLike+From<i32> {
1161	type Output = Elastance<T>;
1162	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1163		Elastance{per_F: T::from(self.clone()) / rhs.F}
1164	}
1165}
1166/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1167impl<T> core::ops::Div<&Capacitance<T>> for i32 where T: NumLike+From<i32> {
1168	type Output = Elastance<T>;
1169	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1170		Elastance{per_F: T::from(self) / rhs.F.clone()}
1171	}
1172}
1173/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1174impl<T> core::ops::Div<&Capacitance<T>> for &i32 where T: NumLike+From<i32> {
1175	type Output = Elastance<T>;
1176	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1177		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1178	}
1179}
1180
1181// 1/Capacitance -> Elastance
1182/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1183#[cfg(feature="num-bigfloat")]
1184impl<T> core::ops::Div<Capacitance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
1185	type Output = Elastance<T>;
1186	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1187		Elastance{per_F: T::from(self) / rhs.F}
1188	}
1189}
1190/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1191#[cfg(feature="num-bigfloat")]
1192impl<T> core::ops::Div<Capacitance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
1193	type Output = Elastance<T>;
1194	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1195		Elastance{per_F: T::from(self.clone()) / rhs.F}
1196	}
1197}
1198/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1199#[cfg(feature="num-bigfloat")]
1200impl<T> core::ops::Div<&Capacitance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
1201	type Output = Elastance<T>;
1202	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1203		Elastance{per_F: T::from(self) / rhs.F.clone()}
1204	}
1205}
1206/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1207#[cfg(feature="num-bigfloat")]
1208impl<T> core::ops::Div<&Capacitance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
1209	type Output = Elastance<T>;
1210	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1211		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1212	}
1213}
1214
1215// 1/Capacitance -> Elastance
1216/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1217#[cfg(feature="num-complex")]
1218impl<T> core::ops::Div<Capacitance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
1219	type Output = Elastance<T>;
1220	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1221		Elastance{per_F: T::from(self) / rhs.F}
1222	}
1223}
1224/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1225#[cfg(feature="num-complex")]
1226impl<T> core::ops::Div<Capacitance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
1227	type Output = Elastance<T>;
1228	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1229		Elastance{per_F: T::from(self.clone()) / rhs.F}
1230	}
1231}
1232/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1233#[cfg(feature="num-complex")]
1234impl<T> core::ops::Div<&Capacitance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
1235	type Output = Elastance<T>;
1236	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1237		Elastance{per_F: T::from(self) / rhs.F.clone()}
1238	}
1239}
1240/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1241#[cfg(feature="num-complex")]
1242impl<T> core::ops::Div<&Capacitance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
1243	type Output = Elastance<T>;
1244	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1245		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1246	}
1247}
1248
1249// 1/Capacitance -> Elastance
1250/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1251#[cfg(feature="num-complex")]
1252impl<T> core::ops::Div<Capacitance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
1253	type Output = Elastance<T>;
1254	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1255		Elastance{per_F: T::from(self) / rhs.F}
1256	}
1257}
1258/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1259#[cfg(feature="num-complex")]
1260impl<T> core::ops::Div<Capacitance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
1261	type Output = Elastance<T>;
1262	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1263		Elastance{per_F: T::from(self.clone()) / rhs.F}
1264	}
1265}
1266/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1267#[cfg(feature="num-complex")]
1268impl<T> core::ops::Div<&Capacitance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
1269	type Output = Elastance<T>;
1270	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1271		Elastance{per_F: T::from(self) / rhs.F.clone()}
1272	}
1273}
1274/// Dividing a scalar value by a Capacitance unit value returns a value of type Elastance
1275#[cfg(feature="num-complex")]
1276impl<T> core::ops::Div<&Capacitance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
1277	type Output = Elastance<T>;
1278	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1279		Elastance{per_F: T::from(self.clone()) / rhs.F.clone()}
1280	}
1281}
1282
1283/// The electric charge (aka coulombs) unit type, defined as coulombs in SI units
1284#[derive(UnitStruct, Debug, Clone)]
1285#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
1286pub struct Charge<T: NumLike>{
1287	/// The value of this Electric charge in coulombs
1288	pub C: T
1289}
1290
1291impl<T> Charge<T> where T: NumLike {
1292
1293	/// Returns the standard unit name of electric charge: "coulombs"
1294	pub fn unit_name() -> &'static str { "coulombs" }
1295	
1296	/// Returns the abbreviated name or symbol of electric charge: "C" for coulombs
1297	pub fn unit_symbol() -> &'static str { "C" }
1298	
1299	/// Returns a new electric charge value from the given number of coulombs
1300	///
1301	/// # Arguments
1302	/// * `C` - Any number-like type, representing a quantity of coulombs
1303	pub fn from_C(C: T) -> Self { Charge{C: C} }
1304	
1305	/// Returns a copy of this electric charge value in coulombs
1306	pub fn to_C(&self) -> T { self.C.clone() }
1307
1308	/// Returns a new electric charge value from the given number of coulombs
1309	///
1310	/// # Arguments
1311	/// * `coulombs` - Any number-like type, representing a quantity of coulombs
1312	pub fn from_coulombs(coulombs: T) -> Self { Charge{C: coulombs} }
1313	
1314	/// Returns a copy of this electric charge value in coulombs
1315	pub fn to_coulombs(&self) -> T { self.C.clone() }
1316
1317}
1318
1319impl<T> fmt::Display for Charge<T> where T: NumLike {
1320	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1321		write!(f, "{} {}", &self.C, Self::unit_symbol())
1322	}
1323}
1324
1325impl<T> Charge<T> where T: NumLike+From<f64> {
1326	
1327	/// Returns a copy of this electric charge value in millicoulombs
1328	/// 
1329	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1330	pub fn to_mC(&self) -> T {
1331		return self.C.clone() * T::from(1000.0_f64);
1332	}
1333
1334	/// Returns a new electric charge value from the given number of millicoulombs
1335	/// 
1336	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1337	///
1338	/// # Arguments
1339	/// * `mC` - Any number-like type, representing a quantity of millicoulombs
1340	pub fn from_mC(mC: T) -> Self {
1341		Charge{C: mC * T::from(0.001_f64)}
1342	}
1343
1344	/// Returns a copy of this electric charge value in microcoulombs
1345	/// 
1346	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1347	pub fn to_uC(&self) -> T {
1348		return self.C.clone() * T::from(1000000.0_f64);
1349	}
1350
1351	/// Returns a new electric charge value from the given number of microcoulombs
1352	/// 
1353	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1354	///
1355	/// # Arguments
1356	/// * `uC` - Any number-like type, representing a quantity of microcoulombs
1357	pub fn from_uC(uC: T) -> Self {
1358		Charge{C: uC * T::from(1e-06_f64)}
1359	}
1360
1361	/// Returns a copy of this electric charge value in nanocoulombs
1362	/// 
1363	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1364	pub fn to_nC(&self) -> T {
1365		return self.C.clone() * T::from(1000000000.0_f64);
1366	}
1367
1368	/// Returns a new electric charge value from the given number of nanocoulombs
1369	/// 
1370	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1371	///
1372	/// # Arguments
1373	/// * `nC` - Any number-like type, representing a quantity of nanocoulombs
1374	pub fn from_nC(nC: T) -> Self {
1375		Charge{C: nC * T::from(1e-09_f64)}
1376	}
1377
1378	/// Returns a copy of this electric charge value in kilocoulombs
1379	/// 
1380	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1381	pub fn to_kC(&self) -> T {
1382		return self.C.clone() * T::from(0.001_f64);
1383	}
1384
1385	/// Returns a new electric charge value from the given number of kilocoulombs
1386	/// 
1387	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1388	///
1389	/// # Arguments
1390	/// * `kC` - Any number-like type, representing a quantity of kilocoulombs
1391	pub fn from_kC(kC: T) -> Self {
1392		Charge{C: kC * T::from(1000.0_f64)}
1393	}
1394
1395	/// Returns a copy of this electric charge value in megacoulombs
1396	/// 
1397	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1398	pub fn to_MC(&self) -> T {
1399		return self.C.clone() * T::from(1e-06_f64);
1400	}
1401
1402	/// Returns a new electric charge value from the given number of megacoulombs
1403	/// 
1404	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1405	///
1406	/// # Arguments
1407	/// * `MC` - Any number-like type, representing a quantity of megacoulombs
1408	pub fn from_MC(MC: T) -> Self {
1409		Charge{C: MC * T::from(1000000.0_f64)}
1410	}
1411
1412	/// Returns a copy of this electric charge value in gigacoulombs
1413	/// 
1414	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1415	pub fn to_GC(&self) -> T {
1416		return self.C.clone() * T::from(1e-09_f64);
1417	}
1418
1419	/// Returns a new electric charge value from the given number of gigacoulombs
1420	/// 
1421	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1422	///
1423	/// # Arguments
1424	/// * `GC` - Any number-like type, representing a quantity of gigacoulombs
1425	pub fn from_GC(GC: T) -> Self {
1426		Charge{C: GC * T::from(1000000000.0_f64)}
1427	}
1428
1429	/// Returns a copy of this electric charge value in proton
1430	/// 
1431	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1432	pub fn to_p(&self) -> T {
1433		return self.C.clone() * T::from(6.24150907446076e+18_f64);
1434	}
1435
1436	/// Returns a new electric charge value from the given number of proton
1437	/// 
1438	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1439	///
1440	/// # Arguments
1441	/// * `p` - Any number-like type, representing a quantity of proton
1442	pub fn from_p(p: T) -> Self {
1443		Charge{C: p * T::from(1.6021766340000001e-19_f64)}
1444	}
1445
1446	/// Returns a copy of this electric charge value in electron
1447	/// 
1448	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1449	pub fn to_e(&self) -> T {
1450		return self.C.clone() * T::from(-6.24150907446076e+18_f64);
1451	}
1452
1453	/// Returns a new electric charge value from the given number of electron
1454	/// 
1455	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
1456	///
1457	/// # Arguments
1458	/// * `e` - Any number-like type, representing a quantity of electron
1459	pub fn from_e(e: T) -> Self {
1460		Charge{C: e * T::from(-1.6021766340000001e-19_f64)}
1461	}
1462
1463}
1464
1465
1466/// Multiplying a unit value by a scalar value returns a unit value
1467#[cfg(feature="num-bigfloat")]
1468impl core::ops::Mul<Charge<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
1469	type Output = Charge<num_bigfloat::BigFloat>;
1470	fn mul(self, rhs: Charge<num_bigfloat::BigFloat>) -> Self::Output {
1471		Charge{C: self * rhs.C}
1472	}
1473}
1474/// Multiplying a unit value by a scalar value returns a unit value
1475#[cfg(feature="num-bigfloat")]
1476impl core::ops::Mul<Charge<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
1477	type Output = Charge<num_bigfloat::BigFloat>;
1478	fn mul(self, rhs: Charge<num_bigfloat::BigFloat>) -> Self::Output {
1479		Charge{C: self.clone() * rhs.C}
1480	}
1481}
1482/// Multiplying a unit value by a scalar value returns a unit value
1483#[cfg(feature="num-bigfloat")]
1484impl core::ops::Mul<&Charge<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
1485	type Output = Charge<num_bigfloat::BigFloat>;
1486	fn mul(self, rhs: &Charge<num_bigfloat::BigFloat>) -> Self::Output {
1487		Charge{C: self * rhs.C.clone()}
1488	}
1489}
1490/// Multiplying a unit value by a scalar value returns a unit value
1491#[cfg(feature="num-bigfloat")]
1492impl core::ops::Mul<&Charge<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
1493	type Output = Charge<num_bigfloat::BigFloat>;
1494	fn mul(self, rhs: &Charge<num_bigfloat::BigFloat>) -> Self::Output {
1495		Charge{C: self.clone() * rhs.C.clone()}
1496	}
1497}
1498
1499/// Multiplying a unit value by a scalar value returns a unit value
1500#[cfg(feature="num-complex")]
1501impl core::ops::Mul<Charge<num_complex::Complex32>> for num_complex::Complex32 {
1502	type Output = Charge<num_complex::Complex32>;
1503	fn mul(self, rhs: Charge<num_complex::Complex32>) -> Self::Output {
1504		Charge{C: self * rhs.C}
1505	}
1506}
1507/// Multiplying a unit value by a scalar value returns a unit value
1508#[cfg(feature="num-complex")]
1509impl core::ops::Mul<Charge<num_complex::Complex32>> for &num_complex::Complex32 {
1510	type Output = Charge<num_complex::Complex32>;
1511	fn mul(self, rhs: Charge<num_complex::Complex32>) -> Self::Output {
1512		Charge{C: self.clone() * rhs.C}
1513	}
1514}
1515/// Multiplying a unit value by a scalar value returns a unit value
1516#[cfg(feature="num-complex")]
1517impl core::ops::Mul<&Charge<num_complex::Complex32>> for num_complex::Complex32 {
1518	type Output = Charge<num_complex::Complex32>;
1519	fn mul(self, rhs: &Charge<num_complex::Complex32>) -> Self::Output {
1520		Charge{C: self * rhs.C.clone()}
1521	}
1522}
1523/// Multiplying a unit value by a scalar value returns a unit value
1524#[cfg(feature="num-complex")]
1525impl core::ops::Mul<&Charge<num_complex::Complex32>> for &num_complex::Complex32 {
1526	type Output = Charge<num_complex::Complex32>;
1527	fn mul(self, rhs: &Charge<num_complex::Complex32>) -> Self::Output {
1528		Charge{C: self.clone() * rhs.C.clone()}
1529	}
1530}
1531
1532/// Multiplying a unit value by a scalar value returns a unit value
1533#[cfg(feature="num-complex")]
1534impl core::ops::Mul<Charge<num_complex::Complex64>> for num_complex::Complex64 {
1535	type Output = Charge<num_complex::Complex64>;
1536	fn mul(self, rhs: Charge<num_complex::Complex64>) -> Self::Output {
1537		Charge{C: self * rhs.C}
1538	}
1539}
1540/// Multiplying a unit value by a scalar value returns a unit value
1541#[cfg(feature="num-complex")]
1542impl core::ops::Mul<Charge<num_complex::Complex64>> for &num_complex::Complex64 {
1543	type Output = Charge<num_complex::Complex64>;
1544	fn mul(self, rhs: Charge<num_complex::Complex64>) -> Self::Output {
1545		Charge{C: self.clone() * rhs.C}
1546	}
1547}
1548/// Multiplying a unit value by a scalar value returns a unit value
1549#[cfg(feature="num-complex")]
1550impl core::ops::Mul<&Charge<num_complex::Complex64>> for num_complex::Complex64 {
1551	type Output = Charge<num_complex::Complex64>;
1552	fn mul(self, rhs: &Charge<num_complex::Complex64>) -> Self::Output {
1553		Charge{C: self * rhs.C.clone()}
1554	}
1555}
1556/// Multiplying a unit value by a scalar value returns a unit value
1557#[cfg(feature="num-complex")]
1558impl core::ops::Mul<&Charge<num_complex::Complex64>> for &num_complex::Complex64 {
1559	type Output = Charge<num_complex::Complex64>;
1560	fn mul(self, rhs: &Charge<num_complex::Complex64>) -> Self::Output {
1561		Charge{C: self.clone() * rhs.C.clone()}
1562	}
1563}
1564
1565
1566
1567/// Converts a Charge into the equivalent [uom](https://crates.io/crates/uom) type [ElectricCharge](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricCharge.html)
1568#[cfg(feature = "uom")]
1569impl<T> Into<uom::si::f32::ElectricCharge> for Charge<T> where T: NumLike+Into<f32> {
1570	fn into(self) -> uom::si::f32::ElectricCharge {
1571		uom::si::f32::ElectricCharge::new::<uom::si::electric_charge::coulomb>(self.C.into())
1572	}
1573}
1574
1575/// Creates a Charge from the equivalent [uom](https://crates.io/crates/uom) type [ElectricCharge](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricCharge.html)
1576#[cfg(feature = "uom")]
1577impl<T> From<uom::si::f32::ElectricCharge> for Charge<T> where T: NumLike+From<f32> {
1578	fn from(src: uom::si::f32::ElectricCharge) -> Self {
1579		Charge{C: T::from(src.value)}
1580	}
1581}
1582
1583/// Converts a Charge into the equivalent [uom](https://crates.io/crates/uom) type [ElectricCharge](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricCharge.html)
1584#[cfg(feature = "uom")]
1585impl<T> Into<uom::si::f64::ElectricCharge> for Charge<T> where T: NumLike+Into<f64> {
1586	fn into(self) -> uom::si::f64::ElectricCharge {
1587		uom::si::f64::ElectricCharge::new::<uom::si::electric_charge::coulomb>(self.C.into())
1588	}
1589}
1590
1591/// Creates a Charge from the equivalent [uom](https://crates.io/crates/uom) type [ElectricCharge](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricCharge.html)
1592#[cfg(feature = "uom")]
1593impl<T> From<uom::si::f64::ElectricCharge> for Charge<T> where T: NumLike+From<f64> {
1594	fn from(src: uom::si::f64::ElectricCharge) -> Self {
1595		Charge{C: T::from(src.value)}
1596	}
1597}
1598
1599
1600// Charge / Current -> Time
1601/// Dividing a Charge by a Current returns a value of type Time
1602impl<T> core::ops::Div<Current<T>> for Charge<T> where T: NumLike {
1603	type Output = Time<T>;
1604	fn div(self, rhs: Current<T>) -> Self::Output {
1605		Time{s: self.C / rhs.A}
1606	}
1607}
1608/// Dividing a Charge by a Current returns a value of type Time
1609impl<T> core::ops::Div<Current<T>> for &Charge<T> where T: NumLike {
1610	type Output = Time<T>;
1611	fn div(self, rhs: Current<T>) -> Self::Output {
1612		Time{s: self.C.clone() / rhs.A}
1613	}
1614}
1615/// Dividing a Charge by a Current returns a value of type Time
1616impl<T> core::ops::Div<&Current<T>> for Charge<T> where T: NumLike {
1617	type Output = Time<T>;
1618	fn div(self, rhs: &Current<T>) -> Self::Output {
1619		Time{s: self.C / rhs.A.clone()}
1620	}
1621}
1622/// Dividing a Charge by a Current returns a value of type Time
1623impl<T> core::ops::Div<&Current<T>> for &Charge<T> where T: NumLike {
1624	type Output = Time<T>;
1625	fn div(self, rhs: &Current<T>) -> Self::Output {
1626		Time{s: self.C.clone() / rhs.A.clone()}
1627	}
1628}
1629
1630// Charge * InverseCurrent -> Time
1631/// Multiplying a Charge by a InverseCurrent returns a value of type Time
1632impl<T> core::ops::Mul<InverseCurrent<T>> for Charge<T> where T: NumLike {
1633	type Output = Time<T>;
1634	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
1635		Time{s: self.C * rhs.per_A}
1636	}
1637}
1638/// Multiplying a Charge by a InverseCurrent returns a value of type Time
1639impl<T> core::ops::Mul<InverseCurrent<T>> for &Charge<T> where T: NumLike {
1640	type Output = Time<T>;
1641	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
1642		Time{s: self.C.clone() * rhs.per_A}
1643	}
1644}
1645/// Multiplying a Charge by a InverseCurrent returns a value of type Time
1646impl<T> core::ops::Mul<&InverseCurrent<T>> for Charge<T> where T: NumLike {
1647	type Output = Time<T>;
1648	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
1649		Time{s: self.C * rhs.per_A.clone()}
1650	}
1651}
1652/// Multiplying a Charge by a InverseCurrent returns a value of type Time
1653impl<T> core::ops::Mul<&InverseCurrent<T>> for &Charge<T> where T: NumLike {
1654	type Output = Time<T>;
1655	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
1656		Time{s: self.C.clone() * rhs.per_A.clone()}
1657	}
1658}
1659
1660// Charge / Time -> Current
1661/// Dividing a Charge by a Time returns a value of type Current
1662impl<T> core::ops::Div<Time<T>> for Charge<T> where T: NumLike {
1663	type Output = Current<T>;
1664	fn div(self, rhs: Time<T>) -> Self::Output {
1665		Current{A: self.C / rhs.s}
1666	}
1667}
1668/// Dividing a Charge by a Time returns a value of type Current
1669impl<T> core::ops::Div<Time<T>> for &Charge<T> where T: NumLike {
1670	type Output = Current<T>;
1671	fn div(self, rhs: Time<T>) -> Self::Output {
1672		Current{A: self.C.clone() / rhs.s}
1673	}
1674}
1675/// Dividing a Charge by a Time returns a value of type Current
1676impl<T> core::ops::Div<&Time<T>> for Charge<T> where T: NumLike {
1677	type Output = Current<T>;
1678	fn div(self, rhs: &Time<T>) -> Self::Output {
1679		Current{A: self.C / rhs.s.clone()}
1680	}
1681}
1682/// Dividing a Charge by a Time returns a value of type Current
1683impl<T> core::ops::Div<&Time<T>> for &Charge<T> where T: NumLike {
1684	type Output = Current<T>;
1685	fn div(self, rhs: &Time<T>) -> Self::Output {
1686		Current{A: self.C.clone() / rhs.s.clone()}
1687	}
1688}
1689
1690// Charge / Capacitance -> Voltage
1691/// Dividing a Charge by a Capacitance returns a value of type Voltage
1692impl<T> core::ops::Div<Capacitance<T>> for Charge<T> where T: NumLike {
1693	type Output = Voltage<T>;
1694	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1695		Voltage{V: self.C / rhs.F}
1696	}
1697}
1698/// Dividing a Charge by a Capacitance returns a value of type Voltage
1699impl<T> core::ops::Div<Capacitance<T>> for &Charge<T> where T: NumLike {
1700	type Output = Voltage<T>;
1701	fn div(self, rhs: Capacitance<T>) -> Self::Output {
1702		Voltage{V: self.C.clone() / rhs.F}
1703	}
1704}
1705/// Dividing a Charge by a Capacitance returns a value of type Voltage
1706impl<T> core::ops::Div<&Capacitance<T>> for Charge<T> where T: NumLike {
1707	type Output = Voltage<T>;
1708	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1709		Voltage{V: self.C / rhs.F.clone()}
1710	}
1711}
1712/// Dividing a Charge by a Capacitance returns a value of type Voltage
1713impl<T> core::ops::Div<&Capacitance<T>> for &Charge<T> where T: NumLike {
1714	type Output = Voltage<T>;
1715	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
1716		Voltage{V: self.C.clone() / rhs.F.clone()}
1717	}
1718}
1719
1720// Charge / Conductance -> MagneticFlux
1721/// Dividing a Charge by a Conductance returns a value of type MagneticFlux
1722impl<T> core::ops::Div<Conductance<T>> for Charge<T> where T: NumLike {
1723	type Output = MagneticFlux<T>;
1724	fn div(self, rhs: Conductance<T>) -> Self::Output {
1725		MagneticFlux{Wb: self.C / rhs.S}
1726	}
1727}
1728/// Dividing a Charge by a Conductance returns a value of type MagneticFlux
1729impl<T> core::ops::Div<Conductance<T>> for &Charge<T> where T: NumLike {
1730	type Output = MagneticFlux<T>;
1731	fn div(self, rhs: Conductance<T>) -> Self::Output {
1732		MagneticFlux{Wb: self.C.clone() / rhs.S}
1733	}
1734}
1735/// Dividing a Charge by a Conductance returns a value of type MagneticFlux
1736impl<T> core::ops::Div<&Conductance<T>> for Charge<T> where T: NumLike {
1737	type Output = MagneticFlux<T>;
1738	fn div(self, rhs: &Conductance<T>) -> Self::Output {
1739		MagneticFlux{Wb: self.C / rhs.S.clone()}
1740	}
1741}
1742/// Dividing a Charge by a Conductance returns a value of type MagneticFlux
1743impl<T> core::ops::Div<&Conductance<T>> for &Charge<T> where T: NumLike {
1744	type Output = MagneticFlux<T>;
1745	fn div(self, rhs: &Conductance<T>) -> Self::Output {
1746		MagneticFlux{Wb: self.C.clone() / rhs.S.clone()}
1747	}
1748}
1749
1750// Charge * Elastance -> Voltage
1751/// Multiplying a Charge by a Elastance returns a value of type Voltage
1752impl<T> core::ops::Mul<Elastance<T>> for Charge<T> where T: NumLike {
1753	type Output = Voltage<T>;
1754	fn mul(self, rhs: Elastance<T>) -> Self::Output {
1755		Voltage{V: self.C * rhs.per_F}
1756	}
1757}
1758/// Multiplying a Charge by a Elastance returns a value of type Voltage
1759impl<T> core::ops::Mul<Elastance<T>> for &Charge<T> where T: NumLike {
1760	type Output = Voltage<T>;
1761	fn mul(self, rhs: Elastance<T>) -> Self::Output {
1762		Voltage{V: self.C.clone() * rhs.per_F}
1763	}
1764}
1765/// Multiplying a Charge by a Elastance returns a value of type Voltage
1766impl<T> core::ops::Mul<&Elastance<T>> for Charge<T> where T: NumLike {
1767	type Output = Voltage<T>;
1768	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
1769		Voltage{V: self.C * rhs.per_F.clone()}
1770	}
1771}
1772/// Multiplying a Charge by a Elastance returns a value of type Voltage
1773impl<T> core::ops::Mul<&Elastance<T>> for &Charge<T> where T: NumLike {
1774	type Output = Voltage<T>;
1775	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
1776		Voltage{V: self.C.clone() * rhs.per_F.clone()}
1777	}
1778}
1779
1780// Charge * InverseMagneticFlux -> Conductance
1781/// Multiplying a Charge by a InverseMagneticFlux returns a value of type Conductance
1782impl<T> core::ops::Mul<InverseMagneticFlux<T>> for Charge<T> where T: NumLike {
1783	type Output = Conductance<T>;
1784	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
1785		Conductance{S: self.C * rhs.per_Wb}
1786	}
1787}
1788/// Multiplying a Charge by a InverseMagneticFlux returns a value of type Conductance
1789impl<T> core::ops::Mul<InverseMagneticFlux<T>> for &Charge<T> where T: NumLike {
1790	type Output = Conductance<T>;
1791	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
1792		Conductance{S: self.C.clone() * rhs.per_Wb}
1793	}
1794}
1795/// Multiplying a Charge by a InverseMagneticFlux returns a value of type Conductance
1796impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for Charge<T> where T: NumLike {
1797	type Output = Conductance<T>;
1798	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
1799		Conductance{S: self.C * rhs.per_Wb.clone()}
1800	}
1801}
1802/// Multiplying a Charge by a InverseMagneticFlux returns a value of type Conductance
1803impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for &Charge<T> where T: NumLike {
1804	type Output = Conductance<T>;
1805	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
1806		Conductance{S: self.C.clone() * rhs.per_Wb.clone()}
1807	}
1808}
1809
1810// Charge * InverseVoltage -> Capacitance
1811/// Multiplying a Charge by a InverseVoltage returns a value of type Capacitance
1812impl<T> core::ops::Mul<InverseVoltage<T>> for Charge<T> where T: NumLike {
1813	type Output = Capacitance<T>;
1814	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
1815		Capacitance{F: self.C * rhs.per_V}
1816	}
1817}
1818/// Multiplying a Charge by a InverseVoltage returns a value of type Capacitance
1819impl<T> core::ops::Mul<InverseVoltage<T>> for &Charge<T> where T: NumLike {
1820	type Output = Capacitance<T>;
1821	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
1822		Capacitance{F: self.C.clone() * rhs.per_V}
1823	}
1824}
1825/// Multiplying a Charge by a InverseVoltage returns a value of type Capacitance
1826impl<T> core::ops::Mul<&InverseVoltage<T>> for Charge<T> where T: NumLike {
1827	type Output = Capacitance<T>;
1828	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
1829		Capacitance{F: self.C * rhs.per_V.clone()}
1830	}
1831}
1832/// Multiplying a Charge by a InverseVoltage returns a value of type Capacitance
1833impl<T> core::ops::Mul<&InverseVoltage<T>> for &Charge<T> where T: NumLike {
1834	type Output = Capacitance<T>;
1835	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
1836		Capacitance{F: self.C.clone() * rhs.per_V.clone()}
1837	}
1838}
1839
1840// Charge / InverseVoltage -> Energy
1841/// Dividing a Charge by a InverseVoltage returns a value of type Energy
1842impl<T> core::ops::Div<InverseVoltage<T>> for Charge<T> where T: NumLike {
1843	type Output = Energy<T>;
1844	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
1845		Energy{J: self.C / rhs.per_V}
1846	}
1847}
1848/// Dividing a Charge by a InverseVoltage returns a value of type Energy
1849impl<T> core::ops::Div<InverseVoltage<T>> for &Charge<T> where T: NumLike {
1850	type Output = Energy<T>;
1851	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
1852		Energy{J: self.C.clone() / rhs.per_V}
1853	}
1854}
1855/// Dividing a Charge by a InverseVoltage returns a value of type Energy
1856impl<T> core::ops::Div<&InverseVoltage<T>> for Charge<T> where T: NumLike {
1857	type Output = Energy<T>;
1858	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
1859		Energy{J: self.C / rhs.per_V.clone()}
1860	}
1861}
1862/// Dividing a Charge by a InverseVoltage returns a value of type Energy
1863impl<T> core::ops::Div<&InverseVoltage<T>> for &Charge<T> where T: NumLike {
1864	type Output = Energy<T>;
1865	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
1866		Energy{J: self.C.clone() / rhs.per_V.clone()}
1867	}
1868}
1869
1870// Charge / MagneticFlux -> Conductance
1871/// Dividing a Charge by a MagneticFlux returns a value of type Conductance
1872impl<T> core::ops::Div<MagneticFlux<T>> for Charge<T> where T: NumLike {
1873	type Output = Conductance<T>;
1874	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
1875		Conductance{S: self.C / rhs.Wb}
1876	}
1877}
1878/// Dividing a Charge by a MagneticFlux returns a value of type Conductance
1879impl<T> core::ops::Div<MagneticFlux<T>> for &Charge<T> where T: NumLike {
1880	type Output = Conductance<T>;
1881	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
1882		Conductance{S: self.C.clone() / rhs.Wb}
1883	}
1884}
1885/// Dividing a Charge by a MagneticFlux returns a value of type Conductance
1886impl<T> core::ops::Div<&MagneticFlux<T>> for Charge<T> where T: NumLike {
1887	type Output = Conductance<T>;
1888	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
1889		Conductance{S: self.C / rhs.Wb.clone()}
1890	}
1891}
1892/// Dividing a Charge by a MagneticFlux returns a value of type Conductance
1893impl<T> core::ops::Div<&MagneticFlux<T>> for &Charge<T> where T: NumLike {
1894	type Output = Conductance<T>;
1895	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
1896		Conductance{S: self.C.clone() / rhs.Wb.clone()}
1897	}
1898}
1899
1900// Charge * Resistance -> MagneticFlux
1901/// Multiplying a Charge by a Resistance returns a value of type MagneticFlux
1902impl<T> core::ops::Mul<Resistance<T>> for Charge<T> where T: NumLike {
1903	type Output = MagneticFlux<T>;
1904	fn mul(self, rhs: Resistance<T>) -> Self::Output {
1905		MagneticFlux{Wb: self.C * rhs.Ohm}
1906	}
1907}
1908/// Multiplying a Charge by a Resistance returns a value of type MagneticFlux
1909impl<T> core::ops::Mul<Resistance<T>> for &Charge<T> where T: NumLike {
1910	type Output = MagneticFlux<T>;
1911	fn mul(self, rhs: Resistance<T>) -> Self::Output {
1912		MagneticFlux{Wb: self.C.clone() * rhs.Ohm}
1913	}
1914}
1915/// Multiplying a Charge by a Resistance returns a value of type MagneticFlux
1916impl<T> core::ops::Mul<&Resistance<T>> for Charge<T> where T: NumLike {
1917	type Output = MagneticFlux<T>;
1918	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
1919		MagneticFlux{Wb: self.C * rhs.Ohm.clone()}
1920	}
1921}
1922/// Multiplying a Charge by a Resistance returns a value of type MagneticFlux
1923impl<T> core::ops::Mul<&Resistance<T>> for &Charge<T> where T: NumLike {
1924	type Output = MagneticFlux<T>;
1925	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
1926		MagneticFlux{Wb: self.C.clone() * rhs.Ohm.clone()}
1927	}
1928}
1929
1930// Charge * Voltage -> Energy
1931/// Multiplying a Charge by a Voltage returns a value of type Energy
1932impl<T> core::ops::Mul<Voltage<T>> for Charge<T> where T: NumLike {
1933	type Output = Energy<T>;
1934	fn mul(self, rhs: Voltage<T>) -> Self::Output {
1935		Energy{J: self.C * rhs.V}
1936	}
1937}
1938/// Multiplying a Charge by a Voltage returns a value of type Energy
1939impl<T> core::ops::Mul<Voltage<T>> for &Charge<T> where T: NumLike {
1940	type Output = Energy<T>;
1941	fn mul(self, rhs: Voltage<T>) -> Self::Output {
1942		Energy{J: self.C.clone() * rhs.V}
1943	}
1944}
1945/// Multiplying a Charge by a Voltage returns a value of type Energy
1946impl<T> core::ops::Mul<&Voltage<T>> for Charge<T> where T: NumLike {
1947	type Output = Energy<T>;
1948	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
1949		Energy{J: self.C * rhs.V.clone()}
1950	}
1951}
1952/// Multiplying a Charge by a Voltage returns a value of type Energy
1953impl<T> core::ops::Mul<&Voltage<T>> for &Charge<T> where T: NumLike {
1954	type Output = Energy<T>;
1955	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
1956		Energy{J: self.C.clone() * rhs.V.clone()}
1957	}
1958}
1959
1960// Charge / Voltage -> Capacitance
1961/// Dividing a Charge by a Voltage returns a value of type Capacitance
1962impl<T> core::ops::Div<Voltage<T>> for Charge<T> where T: NumLike {
1963	type Output = Capacitance<T>;
1964	fn div(self, rhs: Voltage<T>) -> Self::Output {
1965		Capacitance{F: self.C / rhs.V}
1966	}
1967}
1968/// Dividing a Charge by a Voltage returns a value of type Capacitance
1969impl<T> core::ops::Div<Voltage<T>> for &Charge<T> where T: NumLike {
1970	type Output = Capacitance<T>;
1971	fn div(self, rhs: Voltage<T>) -> Self::Output {
1972		Capacitance{F: self.C.clone() / rhs.V}
1973	}
1974}
1975/// Dividing a Charge by a Voltage returns a value of type Capacitance
1976impl<T> core::ops::Div<&Voltage<T>> for Charge<T> where T: NumLike {
1977	type Output = Capacitance<T>;
1978	fn div(self, rhs: &Voltage<T>) -> Self::Output {
1979		Capacitance{F: self.C / rhs.V.clone()}
1980	}
1981}
1982/// Dividing a Charge by a Voltage returns a value of type Capacitance
1983impl<T> core::ops::Div<&Voltage<T>> for &Charge<T> where T: NumLike {
1984	type Output = Capacitance<T>;
1985	fn div(self, rhs: &Voltage<T>) -> Self::Output {
1986		Capacitance{F: self.C.clone() / rhs.V.clone()}
1987	}
1988}
1989
1990// Charge / Energy -> InverseVoltage
1991/// Dividing a Charge by a Energy returns a value of type InverseVoltage
1992impl<T> core::ops::Div<Energy<T>> for Charge<T> where T: NumLike {
1993	type Output = InverseVoltage<T>;
1994	fn div(self, rhs: Energy<T>) -> Self::Output {
1995		InverseVoltage{per_V: self.C / rhs.J}
1996	}
1997}
1998/// Dividing a Charge by a Energy returns a value of type InverseVoltage
1999impl<T> core::ops::Div<Energy<T>> for &Charge<T> where T: NumLike {
2000	type Output = InverseVoltage<T>;
2001	fn div(self, rhs: Energy<T>) -> Self::Output {
2002		InverseVoltage{per_V: self.C.clone() / rhs.J}
2003	}
2004}
2005/// Dividing a Charge by a Energy returns a value of type InverseVoltage
2006impl<T> core::ops::Div<&Energy<T>> for Charge<T> where T: NumLike {
2007	type Output = InverseVoltage<T>;
2008	fn div(self, rhs: &Energy<T>) -> Self::Output {
2009		InverseVoltage{per_V: self.C / rhs.J.clone()}
2010	}
2011}
2012/// Dividing a Charge by a Energy returns a value of type InverseVoltage
2013impl<T> core::ops::Div<&Energy<T>> for &Charge<T> where T: NumLike {
2014	type Output = InverseVoltage<T>;
2015	fn div(self, rhs: &Energy<T>) -> Self::Output {
2016		InverseVoltage{per_V: self.C.clone() / rhs.J.clone()}
2017	}
2018}
2019
2020// Charge / Torque -> InverseVoltage
2021/// Dividing a Charge by a Torque returns a value of type InverseVoltage
2022impl<T> core::ops::Div<Torque<T>> for Charge<T> where T: NumLike {
2023	type Output = InverseVoltage<T>;
2024	fn div(self, rhs: Torque<T>) -> Self::Output {
2025		InverseVoltage{per_V: self.C / rhs.Nm}
2026	}
2027}
2028/// Dividing a Charge by a Torque returns a value of type InverseVoltage
2029impl<T> core::ops::Div<Torque<T>> for &Charge<T> where T: NumLike {
2030	type Output = InverseVoltage<T>;
2031	fn div(self, rhs: Torque<T>) -> Self::Output {
2032		InverseVoltage{per_V: self.C.clone() / rhs.Nm}
2033	}
2034}
2035/// Dividing a Charge by a Torque returns a value of type InverseVoltage
2036impl<T> core::ops::Div<&Torque<T>> for Charge<T> where T: NumLike {
2037	type Output = InverseVoltage<T>;
2038	fn div(self, rhs: &Torque<T>) -> Self::Output {
2039		InverseVoltage{per_V: self.C / rhs.Nm.clone()}
2040	}
2041}
2042/// Dividing a Charge by a Torque returns a value of type InverseVoltage
2043impl<T> core::ops::Div<&Torque<T>> for &Charge<T> where T: NumLike {
2044	type Output = InverseVoltage<T>;
2045	fn div(self, rhs: &Torque<T>) -> Self::Output {
2046		InverseVoltage{per_V: self.C.clone() / rhs.Nm.clone()}
2047	}
2048}
2049
2050// Charge * Frequency -> Current
2051/// Multiplying a Charge by a Frequency returns a value of type Current
2052impl<T> core::ops::Mul<Frequency<T>> for Charge<T> where T: NumLike {
2053	type Output = Current<T>;
2054	fn mul(self, rhs: Frequency<T>) -> Self::Output {
2055		Current{A: self.C * rhs.Hz}
2056	}
2057}
2058/// Multiplying a Charge by a Frequency returns a value of type Current
2059impl<T> core::ops::Mul<Frequency<T>> for &Charge<T> where T: NumLike {
2060	type Output = Current<T>;
2061	fn mul(self, rhs: Frequency<T>) -> Self::Output {
2062		Current{A: self.C.clone() * rhs.Hz}
2063	}
2064}
2065/// Multiplying a Charge by a Frequency returns a value of type Current
2066impl<T> core::ops::Mul<&Frequency<T>> for Charge<T> where T: NumLike {
2067	type Output = Current<T>;
2068	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
2069		Current{A: self.C * rhs.Hz.clone()}
2070	}
2071}
2072/// Multiplying a Charge by a Frequency returns a value of type Current
2073impl<T> core::ops::Mul<&Frequency<T>> for &Charge<T> where T: NumLike {
2074	type Output = Current<T>;
2075	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
2076		Current{A: self.C.clone() * rhs.Hz.clone()}
2077	}
2078}
2079
2080// Charge * InverseEnergy -> InverseVoltage
2081/// Multiplying a Charge by a InverseEnergy returns a value of type InverseVoltage
2082impl<T> core::ops::Mul<InverseEnergy<T>> for Charge<T> where T: NumLike {
2083	type Output = InverseVoltage<T>;
2084	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
2085		InverseVoltage{per_V: self.C * rhs.per_J}
2086	}
2087}
2088/// Multiplying a Charge by a InverseEnergy returns a value of type InverseVoltage
2089impl<T> core::ops::Mul<InverseEnergy<T>> for &Charge<T> where T: NumLike {
2090	type Output = InverseVoltage<T>;
2091	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
2092		InverseVoltage{per_V: self.C.clone() * rhs.per_J}
2093	}
2094}
2095/// Multiplying a Charge by a InverseEnergy returns a value of type InverseVoltage
2096impl<T> core::ops::Mul<&InverseEnergy<T>> for Charge<T> where T: NumLike {
2097	type Output = InverseVoltage<T>;
2098	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
2099		InverseVoltage{per_V: self.C * rhs.per_J.clone()}
2100	}
2101}
2102/// Multiplying a Charge by a InverseEnergy returns a value of type InverseVoltage
2103impl<T> core::ops::Mul<&InverseEnergy<T>> for &Charge<T> where T: NumLike {
2104	type Output = InverseVoltage<T>;
2105	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
2106		InverseVoltage{per_V: self.C.clone() * rhs.per_J.clone()}
2107	}
2108}
2109
2110// Charge * InverseTorque -> InverseVoltage
2111/// Multiplying a Charge by a InverseTorque returns a value of type InverseVoltage
2112impl<T> core::ops::Mul<InverseTorque<T>> for Charge<T> where T: NumLike {
2113	type Output = InverseVoltage<T>;
2114	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
2115		InverseVoltage{per_V: self.C * rhs.per_Nm}
2116	}
2117}
2118/// Multiplying a Charge by a InverseTorque returns a value of type InverseVoltage
2119impl<T> core::ops::Mul<InverseTorque<T>> for &Charge<T> where T: NumLike {
2120	type Output = InverseVoltage<T>;
2121	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
2122		InverseVoltage{per_V: self.C.clone() * rhs.per_Nm}
2123	}
2124}
2125/// Multiplying a Charge by a InverseTorque returns a value of type InverseVoltage
2126impl<T> core::ops::Mul<&InverseTorque<T>> for Charge<T> where T: NumLike {
2127	type Output = InverseVoltage<T>;
2128	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
2129		InverseVoltage{per_V: self.C * rhs.per_Nm.clone()}
2130	}
2131}
2132/// Multiplying a Charge by a InverseTorque returns a value of type InverseVoltage
2133impl<T> core::ops::Mul<&InverseTorque<T>> for &Charge<T> where T: NumLike {
2134	type Output = InverseVoltage<T>;
2135	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
2136		InverseVoltage{per_V: self.C.clone() * rhs.per_Nm.clone()}
2137	}
2138}
2139
2140// 1/Charge -> InverseCharge
2141/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2142impl<T> core::ops::Div<Charge<T>> for f64 where T: NumLike+From<f64> {
2143	type Output = InverseCharge<T>;
2144	fn div(self, rhs: Charge<T>) -> Self::Output {
2145		InverseCharge{per_C: T::from(self) / rhs.C}
2146	}
2147}
2148/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2149impl<T> core::ops::Div<Charge<T>> for &f64 where T: NumLike+From<f64> {
2150	type Output = InverseCharge<T>;
2151	fn div(self, rhs: Charge<T>) -> Self::Output {
2152		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2153	}
2154}
2155/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2156impl<T> core::ops::Div<&Charge<T>> for f64 where T: NumLike+From<f64> {
2157	type Output = InverseCharge<T>;
2158	fn div(self, rhs: &Charge<T>) -> Self::Output {
2159		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2160	}
2161}
2162/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2163impl<T> core::ops::Div<&Charge<T>> for &f64 where T: NumLike+From<f64> {
2164	type Output = InverseCharge<T>;
2165	fn div(self, rhs: &Charge<T>) -> Self::Output {
2166		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2167	}
2168}
2169
2170// 1/Charge -> InverseCharge
2171/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2172impl<T> core::ops::Div<Charge<T>> for f32 where T: NumLike+From<f32> {
2173	type Output = InverseCharge<T>;
2174	fn div(self, rhs: Charge<T>) -> Self::Output {
2175		InverseCharge{per_C: T::from(self) / rhs.C}
2176	}
2177}
2178/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2179impl<T> core::ops::Div<Charge<T>> for &f32 where T: NumLike+From<f32> {
2180	type Output = InverseCharge<T>;
2181	fn div(self, rhs: Charge<T>) -> Self::Output {
2182		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2183	}
2184}
2185/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2186impl<T> core::ops::Div<&Charge<T>> for f32 where T: NumLike+From<f32> {
2187	type Output = InverseCharge<T>;
2188	fn div(self, rhs: &Charge<T>) -> Self::Output {
2189		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2190	}
2191}
2192/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2193impl<T> core::ops::Div<&Charge<T>> for &f32 where T: NumLike+From<f32> {
2194	type Output = InverseCharge<T>;
2195	fn div(self, rhs: &Charge<T>) -> Self::Output {
2196		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2197	}
2198}
2199
2200// 1/Charge -> InverseCharge
2201/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2202impl<T> core::ops::Div<Charge<T>> for i64 where T: NumLike+From<i64> {
2203	type Output = InverseCharge<T>;
2204	fn div(self, rhs: Charge<T>) -> Self::Output {
2205		InverseCharge{per_C: T::from(self) / rhs.C}
2206	}
2207}
2208/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2209impl<T> core::ops::Div<Charge<T>> for &i64 where T: NumLike+From<i64> {
2210	type Output = InverseCharge<T>;
2211	fn div(self, rhs: Charge<T>) -> Self::Output {
2212		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2213	}
2214}
2215/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2216impl<T> core::ops::Div<&Charge<T>> for i64 where T: NumLike+From<i64> {
2217	type Output = InverseCharge<T>;
2218	fn div(self, rhs: &Charge<T>) -> Self::Output {
2219		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2220	}
2221}
2222/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2223impl<T> core::ops::Div<&Charge<T>> for &i64 where T: NumLike+From<i64> {
2224	type Output = InverseCharge<T>;
2225	fn div(self, rhs: &Charge<T>) -> Self::Output {
2226		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2227	}
2228}
2229
2230// 1/Charge -> InverseCharge
2231/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2232impl<T> core::ops::Div<Charge<T>> for i32 where T: NumLike+From<i32> {
2233	type Output = InverseCharge<T>;
2234	fn div(self, rhs: Charge<T>) -> Self::Output {
2235		InverseCharge{per_C: T::from(self) / rhs.C}
2236	}
2237}
2238/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2239impl<T> core::ops::Div<Charge<T>> for &i32 where T: NumLike+From<i32> {
2240	type Output = InverseCharge<T>;
2241	fn div(self, rhs: Charge<T>) -> Self::Output {
2242		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2243	}
2244}
2245/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2246impl<T> core::ops::Div<&Charge<T>> for i32 where T: NumLike+From<i32> {
2247	type Output = InverseCharge<T>;
2248	fn div(self, rhs: &Charge<T>) -> Self::Output {
2249		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2250	}
2251}
2252/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2253impl<T> core::ops::Div<&Charge<T>> for &i32 where T: NumLike+From<i32> {
2254	type Output = InverseCharge<T>;
2255	fn div(self, rhs: &Charge<T>) -> Self::Output {
2256		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2257	}
2258}
2259
2260// 1/Charge -> InverseCharge
2261/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2262#[cfg(feature="num-bigfloat")]
2263impl<T> core::ops::Div<Charge<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
2264	type Output = InverseCharge<T>;
2265	fn div(self, rhs: Charge<T>) -> Self::Output {
2266		InverseCharge{per_C: T::from(self) / rhs.C}
2267	}
2268}
2269/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2270#[cfg(feature="num-bigfloat")]
2271impl<T> core::ops::Div<Charge<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
2272	type Output = InverseCharge<T>;
2273	fn div(self, rhs: Charge<T>) -> Self::Output {
2274		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2275	}
2276}
2277/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2278#[cfg(feature="num-bigfloat")]
2279impl<T> core::ops::Div<&Charge<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
2280	type Output = InverseCharge<T>;
2281	fn div(self, rhs: &Charge<T>) -> Self::Output {
2282		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2283	}
2284}
2285/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2286#[cfg(feature="num-bigfloat")]
2287impl<T> core::ops::Div<&Charge<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
2288	type Output = InverseCharge<T>;
2289	fn div(self, rhs: &Charge<T>) -> Self::Output {
2290		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2291	}
2292}
2293
2294// 1/Charge -> InverseCharge
2295/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2296#[cfg(feature="num-complex")]
2297impl<T> core::ops::Div<Charge<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
2298	type Output = InverseCharge<T>;
2299	fn div(self, rhs: Charge<T>) -> Self::Output {
2300		InverseCharge{per_C: T::from(self) / rhs.C}
2301	}
2302}
2303/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2304#[cfg(feature="num-complex")]
2305impl<T> core::ops::Div<Charge<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
2306	type Output = InverseCharge<T>;
2307	fn div(self, rhs: Charge<T>) -> Self::Output {
2308		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2309	}
2310}
2311/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2312#[cfg(feature="num-complex")]
2313impl<T> core::ops::Div<&Charge<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
2314	type Output = InverseCharge<T>;
2315	fn div(self, rhs: &Charge<T>) -> Self::Output {
2316		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2317	}
2318}
2319/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2320#[cfg(feature="num-complex")]
2321impl<T> core::ops::Div<&Charge<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
2322	type Output = InverseCharge<T>;
2323	fn div(self, rhs: &Charge<T>) -> Self::Output {
2324		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2325	}
2326}
2327
2328// 1/Charge -> InverseCharge
2329/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2330#[cfg(feature="num-complex")]
2331impl<T> core::ops::Div<Charge<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
2332	type Output = InverseCharge<T>;
2333	fn div(self, rhs: Charge<T>) -> Self::Output {
2334		InverseCharge{per_C: T::from(self) / rhs.C}
2335	}
2336}
2337/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2338#[cfg(feature="num-complex")]
2339impl<T> core::ops::Div<Charge<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
2340	type Output = InverseCharge<T>;
2341	fn div(self, rhs: Charge<T>) -> Self::Output {
2342		InverseCharge{per_C: T::from(self.clone()) / rhs.C}
2343	}
2344}
2345/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2346#[cfg(feature="num-complex")]
2347impl<T> core::ops::Div<&Charge<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
2348	type Output = InverseCharge<T>;
2349	fn div(self, rhs: &Charge<T>) -> Self::Output {
2350		InverseCharge{per_C: T::from(self) / rhs.C.clone()}
2351	}
2352}
2353/// Dividing a scalar value by a Charge unit value returns a value of type InverseCharge
2354#[cfg(feature="num-complex")]
2355impl<T> core::ops::Div<&Charge<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
2356	type Output = InverseCharge<T>;
2357	fn div(self, rhs: &Charge<T>) -> Self::Output {
2358		InverseCharge{per_C: T::from(self.clone()) / rhs.C.clone()}
2359	}
2360}
2361
2362/// The electrical conductance unit type, defined as siemens in SI units
2363#[derive(UnitStruct, Debug, Clone)]
2364#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
2365pub struct Conductance<T: NumLike>{
2366	/// The value of this Electrical conductance in siemens
2367	pub S: T
2368}
2369
2370impl<T> Conductance<T> where T: NumLike {
2371
2372	/// Returns the standard unit name of electrical conductance: "siemens"
2373	pub fn unit_name() -> &'static str { "siemens" }
2374	
2375	/// Returns the abbreviated name or symbol of electrical conductance: "S" for siemens
2376	pub fn unit_symbol() -> &'static str { "S" }
2377	
2378	/// Returns a new electrical conductance value from the given number of siemens
2379	///
2380	/// # Arguments
2381	/// * `S` - Any number-like type, representing a quantity of siemens
2382	pub fn from_S(S: T) -> Self { Conductance{S: S} }
2383	
2384	/// Returns a copy of this electrical conductance value in siemens
2385	pub fn to_S(&self) -> T { self.S.clone() }
2386
2387	/// Returns a new electrical conductance value from the given number of siemens
2388	///
2389	/// # Arguments
2390	/// * `siemens` - Any number-like type, representing a quantity of siemens
2391	pub fn from_siemens(siemens: T) -> Self { Conductance{S: siemens} }
2392	
2393	/// Returns a copy of this electrical conductance value in siemens
2394	pub fn to_siemens(&self) -> T { self.S.clone() }
2395
2396}
2397
2398impl<T> fmt::Display for Conductance<T> where T: NumLike {
2399	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2400		write!(f, "{} {}", &self.S, Self::unit_symbol())
2401	}
2402}
2403
2404impl<T> Conductance<T> where T: NumLike+From<f64> {
2405	
2406	/// Returns a copy of this electrical conductance value in millisiemens
2407	/// 
2408	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2409	pub fn to_mS(&self) -> T {
2410		return self.S.clone() * T::from(1000.0_f64);
2411	}
2412
2413	/// Returns a new electrical conductance value from the given number of millisiemens
2414	/// 
2415	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2416	///
2417	/// # Arguments
2418	/// * `mS` - Any number-like type, representing a quantity of millisiemens
2419	pub fn from_mS(mS: T) -> Self {
2420		Conductance{S: mS * T::from(0.001_f64)}
2421	}
2422
2423	/// Returns a copy of this electrical conductance value in microsiemens
2424	/// 
2425	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2426	pub fn to_uS(&self) -> T {
2427		return self.S.clone() * T::from(1000000.0_f64);
2428	}
2429
2430	/// Returns a new electrical conductance value from the given number of microsiemens
2431	/// 
2432	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2433	///
2434	/// # Arguments
2435	/// * `uS` - Any number-like type, representing a quantity of microsiemens
2436	pub fn from_uS(uS: T) -> Self {
2437		Conductance{S: uS * T::from(1e-06_f64)}
2438	}
2439
2440	/// Returns a copy of this electrical conductance value in nanosiemens
2441	/// 
2442	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2443	pub fn to_nS(&self) -> T {
2444		return self.S.clone() * T::from(1000000000.0_f64);
2445	}
2446
2447	/// Returns a new electrical conductance value from the given number of nanosiemens
2448	/// 
2449	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2450	///
2451	/// # Arguments
2452	/// * `nS` - Any number-like type, representing a quantity of nanosiemens
2453	pub fn from_nS(nS: T) -> Self {
2454		Conductance{S: nS * T::from(1e-09_f64)}
2455	}
2456
2457	/// Returns a copy of this electrical conductance value in kilosiemens
2458	/// 
2459	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2460	pub fn to_kS(&self) -> T {
2461		return self.S.clone() * T::from(0.001_f64);
2462	}
2463
2464	/// Returns a new electrical conductance value from the given number of kilosiemens
2465	/// 
2466	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2467	///
2468	/// # Arguments
2469	/// * `kS` - Any number-like type, representing a quantity of kilosiemens
2470	pub fn from_kS(kS: T) -> Self {
2471		Conductance{S: kS * T::from(1000.0_f64)}
2472	}
2473
2474	/// Returns a copy of this electrical conductance value in megasiemens
2475	/// 
2476	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2477	pub fn to_MS(&self) -> T {
2478		return self.S.clone() * T::from(1e-06_f64);
2479	}
2480
2481	/// Returns a new electrical conductance value from the given number of megasiemens
2482	/// 
2483	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2484	///
2485	/// # Arguments
2486	/// * `MS` - Any number-like type, representing a quantity of megasiemens
2487	pub fn from_MS(MS: T) -> Self {
2488		Conductance{S: MS * T::from(1000000.0_f64)}
2489	}
2490
2491	/// Returns a copy of this electrical conductance value in gigasiemens
2492	/// 
2493	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2494	pub fn to_GS(&self) -> T {
2495		return self.S.clone() * T::from(1e-09_f64);
2496	}
2497
2498	/// Returns a new electrical conductance value from the given number of gigasiemens
2499	/// 
2500	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
2501	///
2502	/// # Arguments
2503	/// * `GS` - Any number-like type, representing a quantity of gigasiemens
2504	pub fn from_GS(GS: T) -> Self {
2505		Conductance{S: GS * T::from(1000000000.0_f64)}
2506	}
2507
2508}
2509
2510
2511/// Multiplying a unit value by a scalar value returns a unit value
2512#[cfg(feature="num-bigfloat")]
2513impl core::ops::Mul<Conductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
2514	type Output = Conductance<num_bigfloat::BigFloat>;
2515	fn mul(self, rhs: Conductance<num_bigfloat::BigFloat>) -> Self::Output {
2516		Conductance{S: self * rhs.S}
2517	}
2518}
2519/// Multiplying a unit value by a scalar value returns a unit value
2520#[cfg(feature="num-bigfloat")]
2521impl core::ops::Mul<Conductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
2522	type Output = Conductance<num_bigfloat::BigFloat>;
2523	fn mul(self, rhs: Conductance<num_bigfloat::BigFloat>) -> Self::Output {
2524		Conductance{S: self.clone() * rhs.S}
2525	}
2526}
2527/// Multiplying a unit value by a scalar value returns a unit value
2528#[cfg(feature="num-bigfloat")]
2529impl core::ops::Mul<&Conductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
2530	type Output = Conductance<num_bigfloat::BigFloat>;
2531	fn mul(self, rhs: &Conductance<num_bigfloat::BigFloat>) -> Self::Output {
2532		Conductance{S: self * rhs.S.clone()}
2533	}
2534}
2535/// Multiplying a unit value by a scalar value returns a unit value
2536#[cfg(feature="num-bigfloat")]
2537impl core::ops::Mul<&Conductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
2538	type Output = Conductance<num_bigfloat::BigFloat>;
2539	fn mul(self, rhs: &Conductance<num_bigfloat::BigFloat>) -> Self::Output {
2540		Conductance{S: self.clone() * rhs.S.clone()}
2541	}
2542}
2543
2544/// Multiplying a unit value by a scalar value returns a unit value
2545#[cfg(feature="num-complex")]
2546impl core::ops::Mul<Conductance<num_complex::Complex32>> for num_complex::Complex32 {
2547	type Output = Conductance<num_complex::Complex32>;
2548	fn mul(self, rhs: Conductance<num_complex::Complex32>) -> Self::Output {
2549		Conductance{S: self * rhs.S}
2550	}
2551}
2552/// Multiplying a unit value by a scalar value returns a unit value
2553#[cfg(feature="num-complex")]
2554impl core::ops::Mul<Conductance<num_complex::Complex32>> for &num_complex::Complex32 {
2555	type Output = Conductance<num_complex::Complex32>;
2556	fn mul(self, rhs: Conductance<num_complex::Complex32>) -> Self::Output {
2557		Conductance{S: self.clone() * rhs.S}
2558	}
2559}
2560/// Multiplying a unit value by a scalar value returns a unit value
2561#[cfg(feature="num-complex")]
2562impl core::ops::Mul<&Conductance<num_complex::Complex32>> for num_complex::Complex32 {
2563	type Output = Conductance<num_complex::Complex32>;
2564	fn mul(self, rhs: &Conductance<num_complex::Complex32>) -> Self::Output {
2565		Conductance{S: self * rhs.S.clone()}
2566	}
2567}
2568/// Multiplying a unit value by a scalar value returns a unit value
2569#[cfg(feature="num-complex")]
2570impl core::ops::Mul<&Conductance<num_complex::Complex32>> for &num_complex::Complex32 {
2571	type Output = Conductance<num_complex::Complex32>;
2572	fn mul(self, rhs: &Conductance<num_complex::Complex32>) -> Self::Output {
2573		Conductance{S: self.clone() * rhs.S.clone()}
2574	}
2575}
2576
2577/// Multiplying a unit value by a scalar value returns a unit value
2578#[cfg(feature="num-complex")]
2579impl core::ops::Mul<Conductance<num_complex::Complex64>> for num_complex::Complex64 {
2580	type Output = Conductance<num_complex::Complex64>;
2581	fn mul(self, rhs: Conductance<num_complex::Complex64>) -> Self::Output {
2582		Conductance{S: self * rhs.S}
2583	}
2584}
2585/// Multiplying a unit value by a scalar value returns a unit value
2586#[cfg(feature="num-complex")]
2587impl core::ops::Mul<Conductance<num_complex::Complex64>> for &num_complex::Complex64 {
2588	type Output = Conductance<num_complex::Complex64>;
2589	fn mul(self, rhs: Conductance<num_complex::Complex64>) -> Self::Output {
2590		Conductance{S: self.clone() * rhs.S}
2591	}
2592}
2593/// Multiplying a unit value by a scalar value returns a unit value
2594#[cfg(feature="num-complex")]
2595impl core::ops::Mul<&Conductance<num_complex::Complex64>> for num_complex::Complex64 {
2596	type Output = Conductance<num_complex::Complex64>;
2597	fn mul(self, rhs: &Conductance<num_complex::Complex64>) -> Self::Output {
2598		Conductance{S: self * rhs.S.clone()}
2599	}
2600}
2601/// Multiplying a unit value by a scalar value returns a unit value
2602#[cfg(feature="num-complex")]
2603impl core::ops::Mul<&Conductance<num_complex::Complex64>> for &num_complex::Complex64 {
2604	type Output = Conductance<num_complex::Complex64>;
2605	fn mul(self, rhs: &Conductance<num_complex::Complex64>) -> Self::Output {
2606		Conductance{S: self.clone() * rhs.S.clone()}
2607	}
2608}
2609
2610
2611
2612/// Converts a Conductance into the equivalent [uom](https://crates.io/crates/uom) type [ElectricalConductance](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricalConductance.html)
2613#[cfg(feature = "uom")]
2614impl<T> Into<uom::si::f32::ElectricalConductance> for Conductance<T> where T: NumLike+Into<f32> {
2615	fn into(self) -> uom::si::f32::ElectricalConductance {
2616		uom::si::f32::ElectricalConductance::new::<uom::si::electrical_conductance::siemens>(self.S.into())
2617	}
2618}
2619
2620/// Creates a Conductance from the equivalent [uom](https://crates.io/crates/uom) type [ElectricalConductance](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricalConductance.html)
2621#[cfg(feature = "uom")]
2622impl<T> From<uom::si::f32::ElectricalConductance> for Conductance<T> where T: NumLike+From<f32> {
2623	fn from(src: uom::si::f32::ElectricalConductance) -> Self {
2624		Conductance{S: T::from(src.value)}
2625	}
2626}
2627
2628/// Converts a Conductance into the equivalent [uom](https://crates.io/crates/uom) type [ElectricalConductance](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricalConductance.html)
2629#[cfg(feature = "uom")]
2630impl<T> Into<uom::si::f64::ElectricalConductance> for Conductance<T> where T: NumLike+Into<f64> {
2631	fn into(self) -> uom::si::f64::ElectricalConductance {
2632		uom::si::f64::ElectricalConductance::new::<uom::si::electrical_conductance::siemens>(self.S.into())
2633	}
2634}
2635
2636/// Creates a Conductance from the equivalent [uom](https://crates.io/crates/uom) type [ElectricalConductance](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricalConductance.html)
2637#[cfg(feature = "uom")]
2638impl<T> From<uom::si::f64::ElectricalConductance> for Conductance<T> where T: NumLike+From<f64> {
2639	fn from(src: uom::si::f64::ElectricalConductance) -> Self {
2640		Conductance{S: T::from(src.value)}
2641	}
2642}
2643
2644
2645// Conductance / Current -> InverseVoltage
2646/// Dividing a Conductance by a Current returns a value of type InverseVoltage
2647impl<T> core::ops::Div<Current<T>> for Conductance<T> where T: NumLike {
2648	type Output = InverseVoltage<T>;
2649	fn div(self, rhs: Current<T>) -> Self::Output {
2650		InverseVoltage{per_V: self.S / rhs.A}
2651	}
2652}
2653/// Dividing a Conductance by a Current returns a value of type InverseVoltage
2654impl<T> core::ops::Div<Current<T>> for &Conductance<T> where T: NumLike {
2655	type Output = InverseVoltage<T>;
2656	fn div(self, rhs: Current<T>) -> Self::Output {
2657		InverseVoltage{per_V: self.S.clone() / rhs.A}
2658	}
2659}
2660/// Dividing a Conductance by a Current returns a value of type InverseVoltage
2661impl<T> core::ops::Div<&Current<T>> for Conductance<T> where T: NumLike {
2662	type Output = InverseVoltage<T>;
2663	fn div(self, rhs: &Current<T>) -> Self::Output {
2664		InverseVoltage{per_V: self.S / rhs.A.clone()}
2665	}
2666}
2667/// Dividing a Conductance by a Current returns a value of type InverseVoltage
2668impl<T> core::ops::Div<&Current<T>> for &Conductance<T> where T: NumLike {
2669	type Output = InverseVoltage<T>;
2670	fn div(self, rhs: &Current<T>) -> Self::Output {
2671		InverseVoltage{per_V: self.S.clone() / rhs.A.clone()}
2672	}
2673}
2674
2675// Conductance * InverseCurrent -> InverseVoltage
2676/// Multiplying a Conductance by a InverseCurrent returns a value of type InverseVoltage
2677impl<T> core::ops::Mul<InverseCurrent<T>> for Conductance<T> where T: NumLike {
2678	type Output = InverseVoltage<T>;
2679	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
2680		InverseVoltage{per_V: self.S * rhs.per_A}
2681	}
2682}
2683/// Multiplying a Conductance by a InverseCurrent returns a value of type InverseVoltage
2684impl<T> core::ops::Mul<InverseCurrent<T>> for &Conductance<T> where T: NumLike {
2685	type Output = InverseVoltage<T>;
2686	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
2687		InverseVoltage{per_V: self.S.clone() * rhs.per_A}
2688	}
2689}
2690/// Multiplying a Conductance by a InverseCurrent returns a value of type InverseVoltage
2691impl<T> core::ops::Mul<&InverseCurrent<T>> for Conductance<T> where T: NumLike {
2692	type Output = InverseVoltage<T>;
2693	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
2694		InverseVoltage{per_V: self.S * rhs.per_A.clone()}
2695	}
2696}
2697/// Multiplying a Conductance by a InverseCurrent returns a value of type InverseVoltage
2698impl<T> core::ops::Mul<&InverseCurrent<T>> for &Conductance<T> where T: NumLike {
2699	type Output = InverseVoltage<T>;
2700	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
2701		InverseVoltage{per_V: self.S.clone() * rhs.per_A.clone()}
2702	}
2703}
2704
2705// Conductance * Time -> Capacitance
2706/// Multiplying a Conductance by a Time returns a value of type Capacitance
2707impl<T> core::ops::Mul<Time<T>> for Conductance<T> where T: NumLike {
2708	type Output = Capacitance<T>;
2709	fn mul(self, rhs: Time<T>) -> Self::Output {
2710		Capacitance{F: self.S * rhs.s}
2711	}
2712}
2713/// Multiplying a Conductance by a Time returns a value of type Capacitance
2714impl<T> core::ops::Mul<Time<T>> for &Conductance<T> where T: NumLike {
2715	type Output = Capacitance<T>;
2716	fn mul(self, rhs: Time<T>) -> Self::Output {
2717		Capacitance{F: self.S.clone() * rhs.s}
2718	}
2719}
2720/// Multiplying a Conductance by a Time returns a value of type Capacitance
2721impl<T> core::ops::Mul<&Time<T>> for Conductance<T> where T: NumLike {
2722	type Output = Capacitance<T>;
2723	fn mul(self, rhs: &Time<T>) -> Self::Output {
2724		Capacitance{F: self.S * rhs.s.clone()}
2725	}
2726}
2727/// Multiplying a Conductance by a Time returns a value of type Capacitance
2728impl<T> core::ops::Mul<&Time<T>> for &Conductance<T> where T: NumLike {
2729	type Output = Capacitance<T>;
2730	fn mul(self, rhs: &Time<T>) -> Self::Output {
2731		Capacitance{F: self.S.clone() * rhs.s.clone()}
2732	}
2733}
2734
2735// Conductance / Time -> InverseInductance
2736/// Dividing a Conductance by a Time returns a value of type InverseInductance
2737impl<T> core::ops::Div<Time<T>> for Conductance<T> where T: NumLike {
2738	type Output = InverseInductance<T>;
2739	fn div(self, rhs: Time<T>) -> Self::Output {
2740		InverseInductance{per_H: self.S / rhs.s}
2741	}
2742}
2743/// Dividing a Conductance by a Time returns a value of type InverseInductance
2744impl<T> core::ops::Div<Time<T>> for &Conductance<T> where T: NumLike {
2745	type Output = InverseInductance<T>;
2746	fn div(self, rhs: Time<T>) -> Self::Output {
2747		InverseInductance{per_H: self.S.clone() / rhs.s}
2748	}
2749}
2750/// Dividing a Conductance by a Time returns a value of type InverseInductance
2751impl<T> core::ops::Div<&Time<T>> for Conductance<T> where T: NumLike {
2752	type Output = InverseInductance<T>;
2753	fn div(self, rhs: &Time<T>) -> Self::Output {
2754		InverseInductance{per_H: self.S / rhs.s.clone()}
2755	}
2756}
2757/// Dividing a Conductance by a Time returns a value of type InverseInductance
2758impl<T> core::ops::Div<&Time<T>> for &Conductance<T> where T: NumLike {
2759	type Output = InverseInductance<T>;
2760	fn div(self, rhs: &Time<T>) -> Self::Output {
2761		InverseInductance{per_H: self.S.clone() / rhs.s.clone()}
2762	}
2763}
2764
2765// Conductance / Capacitance -> Frequency
2766/// Dividing a Conductance by a Capacitance returns a value of type Frequency
2767impl<T> core::ops::Div<Capacitance<T>> for Conductance<T> where T: NumLike {
2768	type Output = Frequency<T>;
2769	fn div(self, rhs: Capacitance<T>) -> Self::Output {
2770		Frequency{Hz: self.S / rhs.F}
2771	}
2772}
2773/// Dividing a Conductance by a Capacitance returns a value of type Frequency
2774impl<T> core::ops::Div<Capacitance<T>> for &Conductance<T> where T: NumLike {
2775	type Output = Frequency<T>;
2776	fn div(self, rhs: Capacitance<T>) -> Self::Output {
2777		Frequency{Hz: self.S.clone() / rhs.F}
2778	}
2779}
2780/// Dividing a Conductance by a Capacitance returns a value of type Frequency
2781impl<T> core::ops::Div<&Capacitance<T>> for Conductance<T> where T: NumLike {
2782	type Output = Frequency<T>;
2783	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
2784		Frequency{Hz: self.S / rhs.F.clone()}
2785	}
2786}
2787/// Dividing a Conductance by a Capacitance returns a value of type Frequency
2788impl<T> core::ops::Div<&Capacitance<T>> for &Conductance<T> where T: NumLike {
2789	type Output = Frequency<T>;
2790	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
2791		Frequency{Hz: self.S.clone() / rhs.F.clone()}
2792	}
2793}
2794
2795// Conductance / Charge -> InverseMagneticFlux
2796/// Dividing a Conductance by a Charge returns a value of type InverseMagneticFlux
2797impl<T> core::ops::Div<Charge<T>> for Conductance<T> where T: NumLike {
2798	type Output = InverseMagneticFlux<T>;
2799	fn div(self, rhs: Charge<T>) -> Self::Output {
2800		InverseMagneticFlux{per_Wb: self.S / rhs.C}
2801	}
2802}
2803/// Dividing a Conductance by a Charge returns a value of type InverseMagneticFlux
2804impl<T> core::ops::Div<Charge<T>> for &Conductance<T> where T: NumLike {
2805	type Output = InverseMagneticFlux<T>;
2806	fn div(self, rhs: Charge<T>) -> Self::Output {
2807		InverseMagneticFlux{per_Wb: self.S.clone() / rhs.C}
2808	}
2809}
2810/// Dividing a Conductance by a Charge returns a value of type InverseMagneticFlux
2811impl<T> core::ops::Div<&Charge<T>> for Conductance<T> where T: NumLike {
2812	type Output = InverseMagneticFlux<T>;
2813	fn div(self, rhs: &Charge<T>) -> Self::Output {
2814		InverseMagneticFlux{per_Wb: self.S / rhs.C.clone()}
2815	}
2816}
2817/// Dividing a Conductance by a Charge returns a value of type InverseMagneticFlux
2818impl<T> core::ops::Div<&Charge<T>> for &Conductance<T> where T: NumLike {
2819	type Output = InverseMagneticFlux<T>;
2820	fn div(self, rhs: &Charge<T>) -> Self::Output {
2821		InverseMagneticFlux{per_Wb: self.S.clone() / rhs.C.clone()}
2822	}
2823}
2824
2825// Conductance * Elastance -> Frequency
2826/// Multiplying a Conductance by a Elastance returns a value of type Frequency
2827impl<T> core::ops::Mul<Elastance<T>> for Conductance<T> where T: NumLike {
2828	type Output = Frequency<T>;
2829	fn mul(self, rhs: Elastance<T>) -> Self::Output {
2830		Frequency{Hz: self.S * rhs.per_F}
2831	}
2832}
2833/// Multiplying a Conductance by a Elastance returns a value of type Frequency
2834impl<T> core::ops::Mul<Elastance<T>> for &Conductance<T> where T: NumLike {
2835	type Output = Frequency<T>;
2836	fn mul(self, rhs: Elastance<T>) -> Self::Output {
2837		Frequency{Hz: self.S.clone() * rhs.per_F}
2838	}
2839}
2840/// Multiplying a Conductance by a Elastance returns a value of type Frequency
2841impl<T> core::ops::Mul<&Elastance<T>> for Conductance<T> where T: NumLike {
2842	type Output = Frequency<T>;
2843	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
2844		Frequency{Hz: self.S * rhs.per_F.clone()}
2845	}
2846}
2847/// Multiplying a Conductance by a Elastance returns a value of type Frequency
2848impl<T> core::ops::Mul<&Elastance<T>> for &Conductance<T> where T: NumLike {
2849	type Output = Frequency<T>;
2850	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
2851		Frequency{Hz: self.S.clone() * rhs.per_F.clone()}
2852	}
2853}
2854
2855// Conductance * Inductance -> Time
2856/// Multiplying a Conductance by a Inductance returns a value of type Time
2857impl<T> core::ops::Mul<Inductance<T>> for Conductance<T> where T: NumLike {
2858	type Output = Time<T>;
2859	fn mul(self, rhs: Inductance<T>) -> Self::Output {
2860		Time{s: self.S * rhs.H}
2861	}
2862}
2863/// Multiplying a Conductance by a Inductance returns a value of type Time
2864impl<T> core::ops::Mul<Inductance<T>> for &Conductance<T> where T: NumLike {
2865	type Output = Time<T>;
2866	fn mul(self, rhs: Inductance<T>) -> Self::Output {
2867		Time{s: self.S.clone() * rhs.H}
2868	}
2869}
2870/// Multiplying a Conductance by a Inductance returns a value of type Time
2871impl<T> core::ops::Mul<&Inductance<T>> for Conductance<T> where T: NumLike {
2872	type Output = Time<T>;
2873	fn mul(self, rhs: &Inductance<T>) -> Self::Output {
2874		Time{s: self.S * rhs.H.clone()}
2875	}
2876}
2877/// Multiplying a Conductance by a Inductance returns a value of type Time
2878impl<T> core::ops::Mul<&Inductance<T>> for &Conductance<T> where T: NumLike {
2879	type Output = Time<T>;
2880	fn mul(self, rhs: &Inductance<T>) -> Self::Output {
2881		Time{s: self.S.clone() * rhs.H.clone()}
2882	}
2883}
2884
2885// Conductance * InverseCharge -> InverseMagneticFlux
2886/// Multiplying a Conductance by a InverseCharge returns a value of type InverseMagneticFlux
2887impl<T> core::ops::Mul<InverseCharge<T>> for Conductance<T> where T: NumLike {
2888	type Output = InverseMagneticFlux<T>;
2889	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
2890		InverseMagneticFlux{per_Wb: self.S * rhs.per_C}
2891	}
2892}
2893/// Multiplying a Conductance by a InverseCharge returns a value of type InverseMagneticFlux
2894impl<T> core::ops::Mul<InverseCharge<T>> for &Conductance<T> where T: NumLike {
2895	type Output = InverseMagneticFlux<T>;
2896	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
2897		InverseMagneticFlux{per_Wb: self.S.clone() * rhs.per_C}
2898	}
2899}
2900/// Multiplying a Conductance by a InverseCharge returns a value of type InverseMagneticFlux
2901impl<T> core::ops::Mul<&InverseCharge<T>> for Conductance<T> where T: NumLike {
2902	type Output = InverseMagneticFlux<T>;
2903	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
2904		InverseMagneticFlux{per_Wb: self.S * rhs.per_C.clone()}
2905	}
2906}
2907/// Multiplying a Conductance by a InverseCharge returns a value of type InverseMagneticFlux
2908impl<T> core::ops::Mul<&InverseCharge<T>> for &Conductance<T> where T: NumLike {
2909	type Output = InverseMagneticFlux<T>;
2910	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
2911		InverseMagneticFlux{per_Wb: self.S.clone() * rhs.per_C.clone()}
2912	}
2913}
2914
2915// Conductance / InverseInductance -> Time
2916/// Dividing a Conductance by a InverseInductance returns a value of type Time
2917impl<T> core::ops::Div<InverseInductance<T>> for Conductance<T> where T: NumLike {
2918	type Output = Time<T>;
2919	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
2920		Time{s: self.S / rhs.per_H}
2921	}
2922}
2923/// Dividing a Conductance by a InverseInductance returns a value of type Time
2924impl<T> core::ops::Div<InverseInductance<T>> for &Conductance<T> where T: NumLike {
2925	type Output = Time<T>;
2926	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
2927		Time{s: self.S.clone() / rhs.per_H}
2928	}
2929}
2930/// Dividing a Conductance by a InverseInductance returns a value of type Time
2931impl<T> core::ops::Div<&InverseInductance<T>> for Conductance<T> where T: NumLike {
2932	type Output = Time<T>;
2933	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
2934		Time{s: self.S / rhs.per_H.clone()}
2935	}
2936}
2937/// Dividing a Conductance by a InverseInductance returns a value of type Time
2938impl<T> core::ops::Div<&InverseInductance<T>> for &Conductance<T> where T: NumLike {
2939	type Output = Time<T>;
2940	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
2941		Time{s: self.S.clone() / rhs.per_H.clone()}
2942	}
2943}
2944
2945// Conductance / InverseMagneticFlux -> Charge
2946/// Dividing a Conductance by a InverseMagneticFlux returns a value of type Charge
2947impl<T> core::ops::Div<InverseMagneticFlux<T>> for Conductance<T> where T: NumLike {
2948	type Output = Charge<T>;
2949	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
2950		Charge{C: self.S / rhs.per_Wb}
2951	}
2952}
2953/// Dividing a Conductance by a InverseMagneticFlux returns a value of type Charge
2954impl<T> core::ops::Div<InverseMagneticFlux<T>> for &Conductance<T> where T: NumLike {
2955	type Output = Charge<T>;
2956	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
2957		Charge{C: self.S.clone() / rhs.per_Wb}
2958	}
2959}
2960/// Dividing a Conductance by a InverseMagneticFlux returns a value of type Charge
2961impl<T> core::ops::Div<&InverseMagneticFlux<T>> for Conductance<T> where T: NumLike {
2962	type Output = Charge<T>;
2963	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
2964		Charge{C: self.S / rhs.per_Wb.clone()}
2965	}
2966}
2967/// Dividing a Conductance by a InverseMagneticFlux returns a value of type Charge
2968impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &Conductance<T> where T: NumLike {
2969	type Output = Charge<T>;
2970	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
2971		Charge{C: self.S.clone() / rhs.per_Wb.clone()}
2972	}
2973}
2974
2975// Conductance / InverseVoltage -> Current
2976/// Dividing a Conductance by a InverseVoltage returns a value of type Current
2977impl<T> core::ops::Div<InverseVoltage<T>> for Conductance<T> where T: NumLike {
2978	type Output = Current<T>;
2979	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
2980		Current{A: self.S / rhs.per_V}
2981	}
2982}
2983/// Dividing a Conductance by a InverseVoltage returns a value of type Current
2984impl<T> core::ops::Div<InverseVoltage<T>> for &Conductance<T> where T: NumLike {
2985	type Output = Current<T>;
2986	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
2987		Current{A: self.S.clone() / rhs.per_V}
2988	}
2989}
2990/// Dividing a Conductance by a InverseVoltage returns a value of type Current
2991impl<T> core::ops::Div<&InverseVoltage<T>> for Conductance<T> where T: NumLike {
2992	type Output = Current<T>;
2993	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
2994		Current{A: self.S / rhs.per_V.clone()}
2995	}
2996}
2997/// Dividing a Conductance by a InverseVoltage returns a value of type Current
2998impl<T> core::ops::Div<&InverseVoltage<T>> for &Conductance<T> where T: NumLike {
2999	type Output = Current<T>;
3000	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
3001		Current{A: self.S.clone() / rhs.per_V.clone()}
3002	}
3003}
3004
3005// Conductance * MagneticFlux -> Charge
3006/// Multiplying a Conductance by a MagneticFlux returns a value of type Charge
3007impl<T> core::ops::Mul<MagneticFlux<T>> for Conductance<T> where T: NumLike {
3008	type Output = Charge<T>;
3009	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
3010		Charge{C: self.S * rhs.Wb}
3011	}
3012}
3013/// Multiplying a Conductance by a MagneticFlux returns a value of type Charge
3014impl<T> core::ops::Mul<MagneticFlux<T>> for &Conductance<T> where T: NumLike {
3015	type Output = Charge<T>;
3016	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
3017		Charge{C: self.S.clone() * rhs.Wb}
3018	}
3019}
3020/// Multiplying a Conductance by a MagneticFlux returns a value of type Charge
3021impl<T> core::ops::Mul<&MagneticFlux<T>> for Conductance<T> where T: NumLike {
3022	type Output = Charge<T>;
3023	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
3024		Charge{C: self.S * rhs.Wb.clone()}
3025	}
3026}
3027/// Multiplying a Conductance by a MagneticFlux returns a value of type Charge
3028impl<T> core::ops::Mul<&MagneticFlux<T>> for &Conductance<T> where T: NumLike {
3029	type Output = Charge<T>;
3030	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
3031		Charge{C: self.S.clone() * rhs.Wb.clone()}
3032	}
3033}
3034
3035// Conductance * Voltage -> Current
3036/// Multiplying a Conductance by a Voltage returns a value of type Current
3037impl<T> core::ops::Mul<Voltage<T>> for Conductance<T> where T: NumLike {
3038	type Output = Current<T>;
3039	fn mul(self, rhs: Voltage<T>) -> Self::Output {
3040		Current{A: self.S * rhs.V}
3041	}
3042}
3043/// Multiplying a Conductance by a Voltage returns a value of type Current
3044impl<T> core::ops::Mul<Voltage<T>> for &Conductance<T> where T: NumLike {
3045	type Output = Current<T>;
3046	fn mul(self, rhs: Voltage<T>) -> Self::Output {
3047		Current{A: self.S.clone() * rhs.V}
3048	}
3049}
3050/// Multiplying a Conductance by a Voltage returns a value of type Current
3051impl<T> core::ops::Mul<&Voltage<T>> for Conductance<T> where T: NumLike {
3052	type Output = Current<T>;
3053	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
3054		Current{A: self.S * rhs.V.clone()}
3055	}
3056}
3057/// Multiplying a Conductance by a Voltage returns a value of type Current
3058impl<T> core::ops::Mul<&Voltage<T>> for &Conductance<T> where T: NumLike {
3059	type Output = Current<T>;
3060	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
3061		Current{A: self.S.clone() * rhs.V.clone()}
3062	}
3063}
3064
3065// Conductance * Frequency -> InverseInductance
3066/// Multiplying a Conductance by a Frequency returns a value of type InverseInductance
3067impl<T> core::ops::Mul<Frequency<T>> for Conductance<T> where T: NumLike {
3068	type Output = InverseInductance<T>;
3069	fn mul(self, rhs: Frequency<T>) -> Self::Output {
3070		InverseInductance{per_H: self.S * rhs.Hz}
3071	}
3072}
3073/// Multiplying a Conductance by a Frequency returns a value of type InverseInductance
3074impl<T> core::ops::Mul<Frequency<T>> for &Conductance<T> where T: NumLike {
3075	type Output = InverseInductance<T>;
3076	fn mul(self, rhs: Frequency<T>) -> Self::Output {
3077		InverseInductance{per_H: self.S.clone() * rhs.Hz}
3078	}
3079}
3080/// Multiplying a Conductance by a Frequency returns a value of type InverseInductance
3081impl<T> core::ops::Mul<&Frequency<T>> for Conductance<T> where T: NumLike {
3082	type Output = InverseInductance<T>;
3083	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
3084		InverseInductance{per_H: self.S * rhs.Hz.clone()}
3085	}
3086}
3087/// Multiplying a Conductance by a Frequency returns a value of type InverseInductance
3088impl<T> core::ops::Mul<&Frequency<T>> for &Conductance<T> where T: NumLike {
3089	type Output = InverseInductance<T>;
3090	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
3091		InverseInductance{per_H: self.S.clone() * rhs.Hz.clone()}
3092	}
3093}
3094
3095// Conductance / Frequency -> Capacitance
3096/// Dividing a Conductance by a Frequency returns a value of type Capacitance
3097impl<T> core::ops::Div<Frequency<T>> for Conductance<T> where T: NumLike {
3098	type Output = Capacitance<T>;
3099	fn div(self, rhs: Frequency<T>) -> Self::Output {
3100		Capacitance{F: self.S / rhs.Hz}
3101	}
3102}
3103/// Dividing a Conductance by a Frequency returns a value of type Capacitance
3104impl<T> core::ops::Div<Frequency<T>> for &Conductance<T> where T: NumLike {
3105	type Output = Capacitance<T>;
3106	fn div(self, rhs: Frequency<T>) -> Self::Output {
3107		Capacitance{F: self.S.clone() / rhs.Hz}
3108	}
3109}
3110/// Dividing a Conductance by a Frequency returns a value of type Capacitance
3111impl<T> core::ops::Div<&Frequency<T>> for Conductance<T> where T: NumLike {
3112	type Output = Capacitance<T>;
3113	fn div(self, rhs: &Frequency<T>) -> Self::Output {
3114		Capacitance{F: self.S / rhs.Hz.clone()}
3115	}
3116}
3117/// Dividing a Conductance by a Frequency returns a value of type Capacitance
3118impl<T> core::ops::Div<&Frequency<T>> for &Conductance<T> where T: NumLike {
3119	type Output = Capacitance<T>;
3120	fn div(self, rhs: &Frequency<T>) -> Self::Output {
3121		Capacitance{F: self.S.clone() / rhs.Hz.clone()}
3122	}
3123}
3124
3125// 1/Conductance -> Resistance
3126/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3127impl<T> core::ops::Div<Conductance<T>> for f64 where T: NumLike+From<f64> {
3128	type Output = Resistance<T>;
3129	fn div(self, rhs: Conductance<T>) -> Self::Output {
3130		Resistance{Ohm: T::from(self) / rhs.S}
3131	}
3132}
3133/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3134impl<T> core::ops::Div<Conductance<T>> for &f64 where T: NumLike+From<f64> {
3135	type Output = Resistance<T>;
3136	fn div(self, rhs: Conductance<T>) -> Self::Output {
3137		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3138	}
3139}
3140/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3141impl<T> core::ops::Div<&Conductance<T>> for f64 where T: NumLike+From<f64> {
3142	type Output = Resistance<T>;
3143	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3144		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3145	}
3146}
3147/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3148impl<T> core::ops::Div<&Conductance<T>> for &f64 where T: NumLike+From<f64> {
3149	type Output = Resistance<T>;
3150	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3151		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3152	}
3153}
3154
3155// 1/Conductance -> Resistance
3156/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3157impl<T> core::ops::Div<Conductance<T>> for f32 where T: NumLike+From<f32> {
3158	type Output = Resistance<T>;
3159	fn div(self, rhs: Conductance<T>) -> Self::Output {
3160		Resistance{Ohm: T::from(self) / rhs.S}
3161	}
3162}
3163/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3164impl<T> core::ops::Div<Conductance<T>> for &f32 where T: NumLike+From<f32> {
3165	type Output = Resistance<T>;
3166	fn div(self, rhs: Conductance<T>) -> Self::Output {
3167		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3168	}
3169}
3170/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3171impl<T> core::ops::Div<&Conductance<T>> for f32 where T: NumLike+From<f32> {
3172	type Output = Resistance<T>;
3173	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3174		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3175	}
3176}
3177/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3178impl<T> core::ops::Div<&Conductance<T>> for &f32 where T: NumLike+From<f32> {
3179	type Output = Resistance<T>;
3180	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3181		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3182	}
3183}
3184
3185// 1/Conductance -> Resistance
3186/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3187impl<T> core::ops::Div<Conductance<T>> for i64 where T: NumLike+From<i64> {
3188	type Output = Resistance<T>;
3189	fn div(self, rhs: Conductance<T>) -> Self::Output {
3190		Resistance{Ohm: T::from(self) / rhs.S}
3191	}
3192}
3193/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3194impl<T> core::ops::Div<Conductance<T>> for &i64 where T: NumLike+From<i64> {
3195	type Output = Resistance<T>;
3196	fn div(self, rhs: Conductance<T>) -> Self::Output {
3197		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3198	}
3199}
3200/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3201impl<T> core::ops::Div<&Conductance<T>> for i64 where T: NumLike+From<i64> {
3202	type Output = Resistance<T>;
3203	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3204		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3205	}
3206}
3207/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3208impl<T> core::ops::Div<&Conductance<T>> for &i64 where T: NumLike+From<i64> {
3209	type Output = Resistance<T>;
3210	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3211		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3212	}
3213}
3214
3215// 1/Conductance -> Resistance
3216/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3217impl<T> core::ops::Div<Conductance<T>> for i32 where T: NumLike+From<i32> {
3218	type Output = Resistance<T>;
3219	fn div(self, rhs: Conductance<T>) -> Self::Output {
3220		Resistance{Ohm: T::from(self) / rhs.S}
3221	}
3222}
3223/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3224impl<T> core::ops::Div<Conductance<T>> for &i32 where T: NumLike+From<i32> {
3225	type Output = Resistance<T>;
3226	fn div(self, rhs: Conductance<T>) -> Self::Output {
3227		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3228	}
3229}
3230/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3231impl<T> core::ops::Div<&Conductance<T>> for i32 where T: NumLike+From<i32> {
3232	type Output = Resistance<T>;
3233	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3234		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3235	}
3236}
3237/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3238impl<T> core::ops::Div<&Conductance<T>> for &i32 where T: NumLike+From<i32> {
3239	type Output = Resistance<T>;
3240	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3241		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3242	}
3243}
3244
3245// 1/Conductance -> Resistance
3246/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3247#[cfg(feature="num-bigfloat")]
3248impl<T> core::ops::Div<Conductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3249	type Output = Resistance<T>;
3250	fn div(self, rhs: Conductance<T>) -> Self::Output {
3251		Resistance{Ohm: T::from(self) / rhs.S}
3252	}
3253}
3254/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3255#[cfg(feature="num-bigfloat")]
3256impl<T> core::ops::Div<Conductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3257	type Output = Resistance<T>;
3258	fn div(self, rhs: Conductance<T>) -> Self::Output {
3259		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3260	}
3261}
3262/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3263#[cfg(feature="num-bigfloat")]
3264impl<T> core::ops::Div<&Conductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3265	type Output = Resistance<T>;
3266	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3267		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3268	}
3269}
3270/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3271#[cfg(feature="num-bigfloat")]
3272impl<T> core::ops::Div<&Conductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3273	type Output = Resistance<T>;
3274	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3275		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3276	}
3277}
3278
3279// 1/Conductance -> Resistance
3280/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3281#[cfg(feature="num-complex")]
3282impl<T> core::ops::Div<Conductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
3283	type Output = Resistance<T>;
3284	fn div(self, rhs: Conductance<T>) -> Self::Output {
3285		Resistance{Ohm: T::from(self) / rhs.S}
3286	}
3287}
3288/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3289#[cfg(feature="num-complex")]
3290impl<T> core::ops::Div<Conductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
3291	type Output = Resistance<T>;
3292	fn div(self, rhs: Conductance<T>) -> Self::Output {
3293		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3294	}
3295}
3296/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3297#[cfg(feature="num-complex")]
3298impl<T> core::ops::Div<&Conductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
3299	type Output = Resistance<T>;
3300	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3301		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3302	}
3303}
3304/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3305#[cfg(feature="num-complex")]
3306impl<T> core::ops::Div<&Conductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
3307	type Output = Resistance<T>;
3308	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3309		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3310	}
3311}
3312
3313// 1/Conductance -> Resistance
3314/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3315#[cfg(feature="num-complex")]
3316impl<T> core::ops::Div<Conductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
3317	type Output = Resistance<T>;
3318	fn div(self, rhs: Conductance<T>) -> Self::Output {
3319		Resistance{Ohm: T::from(self) / rhs.S}
3320	}
3321}
3322/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3323#[cfg(feature="num-complex")]
3324impl<T> core::ops::Div<Conductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
3325	type Output = Resistance<T>;
3326	fn div(self, rhs: Conductance<T>) -> Self::Output {
3327		Resistance{Ohm: T::from(self.clone()) / rhs.S}
3328	}
3329}
3330/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3331#[cfg(feature="num-complex")]
3332impl<T> core::ops::Div<&Conductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
3333	type Output = Resistance<T>;
3334	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3335		Resistance{Ohm: T::from(self) / rhs.S.clone()}
3336	}
3337}
3338/// Dividing a scalar value by a Conductance unit value returns a value of type Resistance
3339#[cfg(feature="num-complex")]
3340impl<T> core::ops::Div<&Conductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
3341	type Output = Resistance<T>;
3342	fn div(self, rhs: &Conductance<T>) -> Self::Output {
3343		Resistance{Ohm: T::from(self.clone()) / rhs.S.clone()}
3344	}
3345}
3346
3347/// The electrical elastance unit type, defined as inverse farads in SI units
3348#[derive(UnitStruct, Debug, Clone)]
3349#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
3350pub struct Elastance<T: NumLike>{
3351	/// The value of this Electrical elastance in inverse farads
3352	pub per_F: T
3353}
3354
3355impl<T> Elastance<T> where T: NumLike {
3356
3357	/// Returns the standard unit name of electrical elastance: "inverse farads"
3358	pub fn unit_name() -> &'static str { "inverse farads" }
3359	
3360	/// Returns the abbreviated name or symbol of electrical elastance: "1/F" for inverse farads
3361	pub fn unit_symbol() -> &'static str { "1/F" }
3362	
3363	/// Returns a new electrical elastance value from the given number of inverse farads
3364	///
3365	/// # Arguments
3366	/// * `per_F` - Any number-like type, representing a quantity of inverse farads
3367	pub fn from_per_F(per_F: T) -> Self { Elastance{per_F: per_F} }
3368	
3369	/// Returns a copy of this electrical elastance value in inverse farads
3370	pub fn to_per_F(&self) -> T { self.per_F.clone() }
3371
3372	/// Returns a new electrical elastance value from the given number of inverse farads
3373	///
3374	/// # Arguments
3375	/// * `per_farads` - Any number-like type, representing a quantity of inverse farads
3376	pub fn from_per_farads(per_farads: T) -> Self { Elastance{per_F: per_farads} }
3377	
3378	/// Returns a copy of this electrical elastance value in inverse farads
3379	pub fn to_per_farads(&self) -> T { self.per_F.clone() }
3380
3381}
3382
3383impl<T> fmt::Display for Elastance<T> where T: NumLike {
3384	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3385		write!(f, "{} {}", &self.per_F, Self::unit_symbol())
3386	}
3387}
3388
3389impl<T> Elastance<T> where T: NumLike+From<f64> {
3390	
3391	/// Returns a copy of this electrical elastance value in inverse millifarads
3392	/// 
3393	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3394	pub fn to_per_mF(&self) -> T {
3395		return self.per_F.clone() * T::from(0.001_f64);
3396	}
3397
3398	/// Returns a new electrical elastance value from the given number of inverse millifarads
3399	/// 
3400	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3401	///
3402	/// # Arguments
3403	/// * `per_mF` - Any number-like type, representing a quantity of inverse millifarads
3404	pub fn from_per_mF(per_mF: T) -> Self {
3405		Elastance{per_F: per_mF * T::from(1000.0_f64)}
3406	}
3407
3408	/// Returns a copy of this electrical elastance value in inverse microfarads
3409	/// 
3410	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3411	pub fn to_per_uF(&self) -> T {
3412		return self.per_F.clone() * T::from(1e-06_f64);
3413	}
3414
3415	/// Returns a new electrical elastance value from the given number of inverse microfarads
3416	/// 
3417	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3418	///
3419	/// # Arguments
3420	/// * `per_uF` - Any number-like type, representing a quantity of inverse microfarads
3421	pub fn from_per_uF(per_uF: T) -> Self {
3422		Elastance{per_F: per_uF * T::from(1000000.0_f64)}
3423	}
3424
3425	/// Returns a copy of this electrical elastance value in inverse nanofarads
3426	/// 
3427	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3428	pub fn to_per_nF(&self) -> T {
3429		return self.per_F.clone() * T::from(1e-09_f64);
3430	}
3431
3432	/// Returns a new electrical elastance value from the given number of inverse nanofarads
3433	/// 
3434	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3435	///
3436	/// # Arguments
3437	/// * `per_nF` - Any number-like type, representing a quantity of inverse nanofarads
3438	pub fn from_per_nF(per_nF: T) -> Self {
3439		Elastance{per_F: per_nF * T::from(1000000000.0_f64)}
3440	}
3441
3442	/// Returns a copy of this electrical elastance value in inverse picofarads
3443	/// 
3444	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3445	pub fn to_per_pF(&self) -> T {
3446		return self.per_F.clone() * T::from(1e-12_f64);
3447	}
3448
3449	/// Returns a new electrical elastance value from the given number of inverse picofarads
3450	/// 
3451	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3452	///
3453	/// # Arguments
3454	/// * `per_pF` - Any number-like type, representing a quantity of inverse picofarads
3455	pub fn from_per_pF(per_pF: T) -> Self {
3456		Elastance{per_F: per_pF * T::from(1000000000000.0_f64)}
3457	}
3458
3459	/// Returns a copy of this electrical elastance value in inverse kilofarads
3460	/// 
3461	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3462	pub fn to_per_kF(&self) -> T {
3463		return self.per_F.clone() * T::from(1000.0_f64);
3464	}
3465
3466	/// Returns a new electrical elastance value from the given number of inverse kilofarads
3467	/// 
3468	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3469	///
3470	/// # Arguments
3471	/// * `per_kF` - Any number-like type, representing a quantity of inverse kilofarads
3472	pub fn from_per_kF(per_kF: T) -> Self {
3473		Elastance{per_F: per_kF * T::from(0.001_f64)}
3474	}
3475
3476	/// Returns a copy of this electrical elastance value in inverse megafarads
3477	/// 
3478	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3479	pub fn to_per_MF(&self) -> T {
3480		return self.per_F.clone() * T::from(1000000.0_f64);
3481	}
3482
3483	/// Returns a new electrical elastance value from the given number of inverse megafarads
3484	/// 
3485	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3486	///
3487	/// # Arguments
3488	/// * `per_MF` - Any number-like type, representing a quantity of inverse megafarads
3489	pub fn from_per_MF(per_MF: T) -> Self {
3490		Elastance{per_F: per_MF * T::from(1e-06_f64)}
3491	}
3492
3493	/// Returns a copy of this electrical elastance value in inverse gigafarads
3494	/// 
3495	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3496	pub fn to_per_GF(&self) -> T {
3497		return self.per_F.clone() * T::from(1000000000.0_f64);
3498	}
3499
3500	/// Returns a new electrical elastance value from the given number of inverse gigafarads
3501	/// 
3502	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
3503	///
3504	/// # Arguments
3505	/// * `per_GF` - Any number-like type, representing a quantity of inverse gigafarads
3506	pub fn from_per_GF(per_GF: T) -> Self {
3507		Elastance{per_F: per_GF * T::from(1e-09_f64)}
3508	}
3509
3510}
3511
3512
3513/// Multiplying a unit value by a scalar value returns a unit value
3514#[cfg(feature="num-bigfloat")]
3515impl core::ops::Mul<Elastance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
3516	type Output = Elastance<num_bigfloat::BigFloat>;
3517	fn mul(self, rhs: Elastance<num_bigfloat::BigFloat>) -> Self::Output {
3518		Elastance{per_F: self * rhs.per_F}
3519	}
3520}
3521/// Multiplying a unit value by a scalar value returns a unit value
3522#[cfg(feature="num-bigfloat")]
3523impl core::ops::Mul<Elastance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
3524	type Output = Elastance<num_bigfloat::BigFloat>;
3525	fn mul(self, rhs: Elastance<num_bigfloat::BigFloat>) -> Self::Output {
3526		Elastance{per_F: self.clone() * rhs.per_F}
3527	}
3528}
3529/// Multiplying a unit value by a scalar value returns a unit value
3530#[cfg(feature="num-bigfloat")]
3531impl core::ops::Mul<&Elastance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
3532	type Output = Elastance<num_bigfloat::BigFloat>;
3533	fn mul(self, rhs: &Elastance<num_bigfloat::BigFloat>) -> Self::Output {
3534		Elastance{per_F: self * rhs.per_F.clone()}
3535	}
3536}
3537/// Multiplying a unit value by a scalar value returns a unit value
3538#[cfg(feature="num-bigfloat")]
3539impl core::ops::Mul<&Elastance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
3540	type Output = Elastance<num_bigfloat::BigFloat>;
3541	fn mul(self, rhs: &Elastance<num_bigfloat::BigFloat>) -> Self::Output {
3542		Elastance{per_F: self.clone() * rhs.per_F.clone()}
3543	}
3544}
3545
3546/// Multiplying a unit value by a scalar value returns a unit value
3547#[cfg(feature="num-complex")]
3548impl core::ops::Mul<Elastance<num_complex::Complex32>> for num_complex::Complex32 {
3549	type Output = Elastance<num_complex::Complex32>;
3550	fn mul(self, rhs: Elastance<num_complex::Complex32>) -> Self::Output {
3551		Elastance{per_F: self * rhs.per_F}
3552	}
3553}
3554/// Multiplying a unit value by a scalar value returns a unit value
3555#[cfg(feature="num-complex")]
3556impl core::ops::Mul<Elastance<num_complex::Complex32>> for &num_complex::Complex32 {
3557	type Output = Elastance<num_complex::Complex32>;
3558	fn mul(self, rhs: Elastance<num_complex::Complex32>) -> Self::Output {
3559		Elastance{per_F: self.clone() * rhs.per_F}
3560	}
3561}
3562/// Multiplying a unit value by a scalar value returns a unit value
3563#[cfg(feature="num-complex")]
3564impl core::ops::Mul<&Elastance<num_complex::Complex32>> for num_complex::Complex32 {
3565	type Output = Elastance<num_complex::Complex32>;
3566	fn mul(self, rhs: &Elastance<num_complex::Complex32>) -> Self::Output {
3567		Elastance{per_F: self * rhs.per_F.clone()}
3568	}
3569}
3570/// Multiplying a unit value by a scalar value returns a unit value
3571#[cfg(feature="num-complex")]
3572impl core::ops::Mul<&Elastance<num_complex::Complex32>> for &num_complex::Complex32 {
3573	type Output = Elastance<num_complex::Complex32>;
3574	fn mul(self, rhs: &Elastance<num_complex::Complex32>) -> Self::Output {
3575		Elastance{per_F: self.clone() * rhs.per_F.clone()}
3576	}
3577}
3578
3579/// Multiplying a unit value by a scalar value returns a unit value
3580#[cfg(feature="num-complex")]
3581impl core::ops::Mul<Elastance<num_complex::Complex64>> for num_complex::Complex64 {
3582	type Output = Elastance<num_complex::Complex64>;
3583	fn mul(self, rhs: Elastance<num_complex::Complex64>) -> Self::Output {
3584		Elastance{per_F: self * rhs.per_F}
3585	}
3586}
3587/// Multiplying a unit value by a scalar value returns a unit value
3588#[cfg(feature="num-complex")]
3589impl core::ops::Mul<Elastance<num_complex::Complex64>> for &num_complex::Complex64 {
3590	type Output = Elastance<num_complex::Complex64>;
3591	fn mul(self, rhs: Elastance<num_complex::Complex64>) -> Self::Output {
3592		Elastance{per_F: self.clone() * rhs.per_F}
3593	}
3594}
3595/// Multiplying a unit value by a scalar value returns a unit value
3596#[cfg(feature="num-complex")]
3597impl core::ops::Mul<&Elastance<num_complex::Complex64>> for num_complex::Complex64 {
3598	type Output = Elastance<num_complex::Complex64>;
3599	fn mul(self, rhs: &Elastance<num_complex::Complex64>) -> Self::Output {
3600		Elastance{per_F: self * rhs.per_F.clone()}
3601	}
3602}
3603/// Multiplying a unit value by a scalar value returns a unit value
3604#[cfg(feature="num-complex")]
3605impl core::ops::Mul<&Elastance<num_complex::Complex64>> for &num_complex::Complex64 {
3606	type Output = Elastance<num_complex::Complex64>;
3607	fn mul(self, rhs: &Elastance<num_complex::Complex64>) -> Self::Output {
3608		Elastance{per_F: self.clone() * rhs.per_F.clone()}
3609	}
3610}
3611
3612
3613
3614
3615// Elastance * Time -> Resistance
3616/// Multiplying a Elastance by a Time returns a value of type Resistance
3617impl<T> core::ops::Mul<Time<T>> for Elastance<T> where T: NumLike {
3618	type Output = Resistance<T>;
3619	fn mul(self, rhs: Time<T>) -> Self::Output {
3620		Resistance{Ohm: self.per_F * rhs.s}
3621	}
3622}
3623/// Multiplying a Elastance by a Time returns a value of type Resistance
3624impl<T> core::ops::Mul<Time<T>> for &Elastance<T> where T: NumLike {
3625	type Output = Resistance<T>;
3626	fn mul(self, rhs: Time<T>) -> Self::Output {
3627		Resistance{Ohm: self.per_F.clone() * rhs.s}
3628	}
3629}
3630/// Multiplying a Elastance by a Time returns a value of type Resistance
3631impl<T> core::ops::Mul<&Time<T>> for Elastance<T> where T: NumLike {
3632	type Output = Resistance<T>;
3633	fn mul(self, rhs: &Time<T>) -> Self::Output {
3634		Resistance{Ohm: self.per_F * rhs.s.clone()}
3635	}
3636}
3637/// Multiplying a Elastance by a Time returns a value of type Resistance
3638impl<T> core::ops::Mul<&Time<T>> for &Elastance<T> where T: NumLike {
3639	type Output = Resistance<T>;
3640	fn mul(self, rhs: &Time<T>) -> Self::Output {
3641		Resistance{Ohm: self.per_F.clone() * rhs.s.clone()}
3642	}
3643}
3644
3645// Elastance * Charge -> Voltage
3646/// Multiplying a Elastance by a Charge returns a value of type Voltage
3647impl<T> core::ops::Mul<Charge<T>> for Elastance<T> where T: NumLike {
3648	type Output = Voltage<T>;
3649	fn mul(self, rhs: Charge<T>) -> Self::Output {
3650		Voltage{V: self.per_F * rhs.C}
3651	}
3652}
3653/// Multiplying a Elastance by a Charge returns a value of type Voltage
3654impl<T> core::ops::Mul<Charge<T>> for &Elastance<T> where T: NumLike {
3655	type Output = Voltage<T>;
3656	fn mul(self, rhs: Charge<T>) -> Self::Output {
3657		Voltage{V: self.per_F.clone() * rhs.C}
3658	}
3659}
3660/// Multiplying a Elastance by a Charge returns a value of type Voltage
3661impl<T> core::ops::Mul<&Charge<T>> for Elastance<T> where T: NumLike {
3662	type Output = Voltage<T>;
3663	fn mul(self, rhs: &Charge<T>) -> Self::Output {
3664		Voltage{V: self.per_F * rhs.C.clone()}
3665	}
3666}
3667/// Multiplying a Elastance by a Charge returns a value of type Voltage
3668impl<T> core::ops::Mul<&Charge<T>> for &Elastance<T> where T: NumLike {
3669	type Output = Voltage<T>;
3670	fn mul(self, rhs: &Charge<T>) -> Self::Output {
3671		Voltage{V: self.per_F.clone() * rhs.C.clone()}
3672	}
3673}
3674
3675// Elastance * Conductance -> Frequency
3676/// Multiplying a Elastance by a Conductance returns a value of type Frequency
3677impl<T> core::ops::Mul<Conductance<T>> for Elastance<T> where T: NumLike {
3678	type Output = Frequency<T>;
3679	fn mul(self, rhs: Conductance<T>) -> Self::Output {
3680		Frequency{Hz: self.per_F * rhs.S}
3681	}
3682}
3683/// Multiplying a Elastance by a Conductance returns a value of type Frequency
3684impl<T> core::ops::Mul<Conductance<T>> for &Elastance<T> where T: NumLike {
3685	type Output = Frequency<T>;
3686	fn mul(self, rhs: Conductance<T>) -> Self::Output {
3687		Frequency{Hz: self.per_F.clone() * rhs.S}
3688	}
3689}
3690/// Multiplying a Elastance by a Conductance returns a value of type Frequency
3691impl<T> core::ops::Mul<&Conductance<T>> for Elastance<T> where T: NumLike {
3692	type Output = Frequency<T>;
3693	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
3694		Frequency{Hz: self.per_F * rhs.S.clone()}
3695	}
3696}
3697/// Multiplying a Elastance by a Conductance returns a value of type Frequency
3698impl<T> core::ops::Mul<&Conductance<T>> for &Elastance<T> where T: NumLike {
3699	type Output = Frequency<T>;
3700	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
3701		Frequency{Hz: self.per_F.clone() * rhs.S.clone()}
3702	}
3703}
3704
3705// Elastance / InverseCharge -> Voltage
3706/// Dividing a Elastance by a InverseCharge returns a value of type Voltage
3707impl<T> core::ops::Div<InverseCharge<T>> for Elastance<T> where T: NumLike {
3708	type Output = Voltage<T>;
3709	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
3710		Voltage{V: self.per_F / rhs.per_C}
3711	}
3712}
3713/// Dividing a Elastance by a InverseCharge returns a value of type Voltage
3714impl<T> core::ops::Div<InverseCharge<T>> for &Elastance<T> where T: NumLike {
3715	type Output = Voltage<T>;
3716	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
3717		Voltage{V: self.per_F.clone() / rhs.per_C}
3718	}
3719}
3720/// Dividing a Elastance by a InverseCharge returns a value of type Voltage
3721impl<T> core::ops::Div<&InverseCharge<T>> for Elastance<T> where T: NumLike {
3722	type Output = Voltage<T>;
3723	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
3724		Voltage{V: self.per_F / rhs.per_C.clone()}
3725	}
3726}
3727/// Dividing a Elastance by a InverseCharge returns a value of type Voltage
3728impl<T> core::ops::Div<&InverseCharge<T>> for &Elastance<T> where T: NumLike {
3729	type Output = Voltage<T>;
3730	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
3731		Voltage{V: self.per_F.clone() / rhs.per_C.clone()}
3732	}
3733}
3734
3735// Elastance * InverseVoltage -> InverseCharge
3736/// Multiplying a Elastance by a InverseVoltage returns a value of type InverseCharge
3737impl<T> core::ops::Mul<InverseVoltage<T>> for Elastance<T> where T: NumLike {
3738	type Output = InverseCharge<T>;
3739	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
3740		InverseCharge{per_C: self.per_F * rhs.per_V}
3741	}
3742}
3743/// Multiplying a Elastance by a InverseVoltage returns a value of type InverseCharge
3744impl<T> core::ops::Mul<InverseVoltage<T>> for &Elastance<T> where T: NumLike {
3745	type Output = InverseCharge<T>;
3746	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
3747		InverseCharge{per_C: self.per_F.clone() * rhs.per_V}
3748	}
3749}
3750/// Multiplying a Elastance by a InverseVoltage returns a value of type InverseCharge
3751impl<T> core::ops::Mul<&InverseVoltage<T>> for Elastance<T> where T: NumLike {
3752	type Output = InverseCharge<T>;
3753	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
3754		InverseCharge{per_C: self.per_F * rhs.per_V.clone()}
3755	}
3756}
3757/// Multiplying a Elastance by a InverseVoltage returns a value of type InverseCharge
3758impl<T> core::ops::Mul<&InverseVoltage<T>> for &Elastance<T> where T: NumLike {
3759	type Output = InverseCharge<T>;
3760	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
3761		InverseCharge{per_C: self.per_F.clone() * rhs.per_V.clone()}
3762	}
3763}
3764
3765// Elastance / Resistance -> Frequency
3766/// Dividing a Elastance by a Resistance returns a value of type Frequency
3767impl<T> core::ops::Div<Resistance<T>> for Elastance<T> where T: NumLike {
3768	type Output = Frequency<T>;
3769	fn div(self, rhs: Resistance<T>) -> Self::Output {
3770		Frequency{Hz: self.per_F / rhs.Ohm}
3771	}
3772}
3773/// Dividing a Elastance by a Resistance returns a value of type Frequency
3774impl<T> core::ops::Div<Resistance<T>> for &Elastance<T> where T: NumLike {
3775	type Output = Frequency<T>;
3776	fn div(self, rhs: Resistance<T>) -> Self::Output {
3777		Frequency{Hz: self.per_F.clone() / rhs.Ohm}
3778	}
3779}
3780/// Dividing a Elastance by a Resistance returns a value of type Frequency
3781impl<T> core::ops::Div<&Resistance<T>> for Elastance<T> where T: NumLike {
3782	type Output = Frequency<T>;
3783	fn div(self, rhs: &Resistance<T>) -> Self::Output {
3784		Frequency{Hz: self.per_F / rhs.Ohm.clone()}
3785	}
3786}
3787/// Dividing a Elastance by a Resistance returns a value of type Frequency
3788impl<T> core::ops::Div<&Resistance<T>> for &Elastance<T> where T: NumLike {
3789	type Output = Frequency<T>;
3790	fn div(self, rhs: &Resistance<T>) -> Self::Output {
3791		Frequency{Hz: self.per_F.clone() / rhs.Ohm.clone()}
3792	}
3793}
3794
3795// Elastance / Voltage -> InverseCharge
3796/// Dividing a Elastance by a Voltage returns a value of type InverseCharge
3797impl<T> core::ops::Div<Voltage<T>> for Elastance<T> where T: NumLike {
3798	type Output = InverseCharge<T>;
3799	fn div(self, rhs: Voltage<T>) -> Self::Output {
3800		InverseCharge{per_C: self.per_F / rhs.V}
3801	}
3802}
3803/// Dividing a Elastance by a Voltage returns a value of type InverseCharge
3804impl<T> core::ops::Div<Voltage<T>> for &Elastance<T> where T: NumLike {
3805	type Output = InverseCharge<T>;
3806	fn div(self, rhs: Voltage<T>) -> Self::Output {
3807		InverseCharge{per_C: self.per_F.clone() / rhs.V}
3808	}
3809}
3810/// Dividing a Elastance by a Voltage returns a value of type InverseCharge
3811impl<T> core::ops::Div<&Voltage<T>> for Elastance<T> where T: NumLike {
3812	type Output = InverseCharge<T>;
3813	fn div(self, rhs: &Voltage<T>) -> Self::Output {
3814		InverseCharge{per_C: self.per_F / rhs.V.clone()}
3815	}
3816}
3817/// Dividing a Elastance by a Voltage returns a value of type InverseCharge
3818impl<T> core::ops::Div<&Voltage<T>> for &Elastance<T> where T: NumLike {
3819	type Output = InverseCharge<T>;
3820	fn div(self, rhs: &Voltage<T>) -> Self::Output {
3821		InverseCharge{per_C: self.per_F.clone() / rhs.V.clone()}
3822	}
3823}
3824
3825// Elastance / Frequency -> Resistance
3826/// Dividing a Elastance by a Frequency returns a value of type Resistance
3827impl<T> core::ops::Div<Frequency<T>> for Elastance<T> where T: NumLike {
3828	type Output = Resistance<T>;
3829	fn div(self, rhs: Frequency<T>) -> Self::Output {
3830		Resistance{Ohm: self.per_F / rhs.Hz}
3831	}
3832}
3833/// Dividing a Elastance by a Frequency returns a value of type Resistance
3834impl<T> core::ops::Div<Frequency<T>> for &Elastance<T> where T: NumLike {
3835	type Output = Resistance<T>;
3836	fn div(self, rhs: Frequency<T>) -> Self::Output {
3837		Resistance{Ohm: self.per_F.clone() / rhs.Hz}
3838	}
3839}
3840/// Dividing a Elastance by a Frequency returns a value of type Resistance
3841impl<T> core::ops::Div<&Frequency<T>> for Elastance<T> where T: NumLike {
3842	type Output = Resistance<T>;
3843	fn div(self, rhs: &Frequency<T>) -> Self::Output {
3844		Resistance{Ohm: self.per_F / rhs.Hz.clone()}
3845	}
3846}
3847/// Dividing a Elastance by a Frequency returns a value of type Resistance
3848impl<T> core::ops::Div<&Frequency<T>> for &Elastance<T> where T: NumLike {
3849	type Output = Resistance<T>;
3850	fn div(self, rhs: &Frequency<T>) -> Self::Output {
3851		Resistance{Ohm: self.per_F.clone() / rhs.Hz.clone()}
3852	}
3853}
3854
3855// 1/Elastance -> Capacitance
3856/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3857impl<T> core::ops::Div<Elastance<T>> for f64 where T: NumLike+From<f64> {
3858	type Output = Capacitance<T>;
3859	fn div(self, rhs: Elastance<T>) -> Self::Output {
3860		Capacitance{F: T::from(self) / rhs.per_F}
3861	}
3862}
3863/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3864impl<T> core::ops::Div<Elastance<T>> for &f64 where T: NumLike+From<f64> {
3865	type Output = Capacitance<T>;
3866	fn div(self, rhs: Elastance<T>) -> Self::Output {
3867		Capacitance{F: T::from(self.clone()) / rhs.per_F}
3868	}
3869}
3870/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3871impl<T> core::ops::Div<&Elastance<T>> for f64 where T: NumLike+From<f64> {
3872	type Output = Capacitance<T>;
3873	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3874		Capacitance{F: T::from(self) / rhs.per_F.clone()}
3875	}
3876}
3877/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3878impl<T> core::ops::Div<&Elastance<T>> for &f64 where T: NumLike+From<f64> {
3879	type Output = Capacitance<T>;
3880	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3881		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
3882	}
3883}
3884
3885// 1/Elastance -> Capacitance
3886/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3887impl<T> core::ops::Div<Elastance<T>> for f32 where T: NumLike+From<f32> {
3888	type Output = Capacitance<T>;
3889	fn div(self, rhs: Elastance<T>) -> Self::Output {
3890		Capacitance{F: T::from(self) / rhs.per_F}
3891	}
3892}
3893/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3894impl<T> core::ops::Div<Elastance<T>> for &f32 where T: NumLike+From<f32> {
3895	type Output = Capacitance<T>;
3896	fn div(self, rhs: Elastance<T>) -> Self::Output {
3897		Capacitance{F: T::from(self.clone()) / rhs.per_F}
3898	}
3899}
3900/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3901impl<T> core::ops::Div<&Elastance<T>> for f32 where T: NumLike+From<f32> {
3902	type Output = Capacitance<T>;
3903	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3904		Capacitance{F: T::from(self) / rhs.per_F.clone()}
3905	}
3906}
3907/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3908impl<T> core::ops::Div<&Elastance<T>> for &f32 where T: NumLike+From<f32> {
3909	type Output = Capacitance<T>;
3910	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3911		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
3912	}
3913}
3914
3915// 1/Elastance -> Capacitance
3916/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3917impl<T> core::ops::Div<Elastance<T>> for i64 where T: NumLike+From<i64> {
3918	type Output = Capacitance<T>;
3919	fn div(self, rhs: Elastance<T>) -> Self::Output {
3920		Capacitance{F: T::from(self) / rhs.per_F}
3921	}
3922}
3923/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3924impl<T> core::ops::Div<Elastance<T>> for &i64 where T: NumLike+From<i64> {
3925	type Output = Capacitance<T>;
3926	fn div(self, rhs: Elastance<T>) -> Self::Output {
3927		Capacitance{F: T::from(self.clone()) / rhs.per_F}
3928	}
3929}
3930/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3931impl<T> core::ops::Div<&Elastance<T>> for i64 where T: NumLike+From<i64> {
3932	type Output = Capacitance<T>;
3933	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3934		Capacitance{F: T::from(self) / rhs.per_F.clone()}
3935	}
3936}
3937/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3938impl<T> core::ops::Div<&Elastance<T>> for &i64 where T: NumLike+From<i64> {
3939	type Output = Capacitance<T>;
3940	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3941		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
3942	}
3943}
3944
3945// 1/Elastance -> Capacitance
3946/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3947impl<T> core::ops::Div<Elastance<T>> for i32 where T: NumLike+From<i32> {
3948	type Output = Capacitance<T>;
3949	fn div(self, rhs: Elastance<T>) -> Self::Output {
3950		Capacitance{F: T::from(self) / rhs.per_F}
3951	}
3952}
3953/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3954impl<T> core::ops::Div<Elastance<T>> for &i32 where T: NumLike+From<i32> {
3955	type Output = Capacitance<T>;
3956	fn div(self, rhs: Elastance<T>) -> Self::Output {
3957		Capacitance{F: T::from(self.clone()) / rhs.per_F}
3958	}
3959}
3960/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3961impl<T> core::ops::Div<&Elastance<T>> for i32 where T: NumLike+From<i32> {
3962	type Output = Capacitance<T>;
3963	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3964		Capacitance{F: T::from(self) / rhs.per_F.clone()}
3965	}
3966}
3967/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3968impl<T> core::ops::Div<&Elastance<T>> for &i32 where T: NumLike+From<i32> {
3969	type Output = Capacitance<T>;
3970	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3971		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
3972	}
3973}
3974
3975// 1/Elastance -> Capacitance
3976/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3977#[cfg(feature="num-bigfloat")]
3978impl<T> core::ops::Div<Elastance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3979	type Output = Capacitance<T>;
3980	fn div(self, rhs: Elastance<T>) -> Self::Output {
3981		Capacitance{F: T::from(self) / rhs.per_F}
3982	}
3983}
3984/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3985#[cfg(feature="num-bigfloat")]
3986impl<T> core::ops::Div<Elastance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3987	type Output = Capacitance<T>;
3988	fn div(self, rhs: Elastance<T>) -> Self::Output {
3989		Capacitance{F: T::from(self.clone()) / rhs.per_F}
3990	}
3991}
3992/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
3993#[cfg(feature="num-bigfloat")]
3994impl<T> core::ops::Div<&Elastance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
3995	type Output = Capacitance<T>;
3996	fn div(self, rhs: &Elastance<T>) -> Self::Output {
3997		Capacitance{F: T::from(self) / rhs.per_F.clone()}
3998	}
3999}
4000/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4001#[cfg(feature="num-bigfloat")]
4002impl<T> core::ops::Div<&Elastance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
4003	type Output = Capacitance<T>;
4004	fn div(self, rhs: &Elastance<T>) -> Self::Output {
4005		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
4006	}
4007}
4008
4009// 1/Elastance -> Capacitance
4010/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4011#[cfg(feature="num-complex")]
4012impl<T> core::ops::Div<Elastance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4013	type Output = Capacitance<T>;
4014	fn div(self, rhs: Elastance<T>) -> Self::Output {
4015		Capacitance{F: T::from(self) / rhs.per_F}
4016	}
4017}
4018/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4019#[cfg(feature="num-complex")]
4020impl<T> core::ops::Div<Elastance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4021	type Output = Capacitance<T>;
4022	fn div(self, rhs: Elastance<T>) -> Self::Output {
4023		Capacitance{F: T::from(self.clone()) / rhs.per_F}
4024	}
4025}
4026/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4027#[cfg(feature="num-complex")]
4028impl<T> core::ops::Div<&Elastance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4029	type Output = Capacitance<T>;
4030	fn div(self, rhs: &Elastance<T>) -> Self::Output {
4031		Capacitance{F: T::from(self) / rhs.per_F.clone()}
4032	}
4033}
4034/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4035#[cfg(feature="num-complex")]
4036impl<T> core::ops::Div<&Elastance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4037	type Output = Capacitance<T>;
4038	fn div(self, rhs: &Elastance<T>) -> Self::Output {
4039		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
4040	}
4041}
4042
4043// 1/Elastance -> Capacitance
4044/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4045#[cfg(feature="num-complex")]
4046impl<T> core::ops::Div<Elastance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4047	type Output = Capacitance<T>;
4048	fn div(self, rhs: Elastance<T>) -> Self::Output {
4049		Capacitance{F: T::from(self) / rhs.per_F}
4050	}
4051}
4052/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4053#[cfg(feature="num-complex")]
4054impl<T> core::ops::Div<Elastance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4055	type Output = Capacitance<T>;
4056	fn div(self, rhs: Elastance<T>) -> Self::Output {
4057		Capacitance{F: T::from(self.clone()) / rhs.per_F}
4058	}
4059}
4060/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4061#[cfg(feature="num-complex")]
4062impl<T> core::ops::Div<&Elastance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4063	type Output = Capacitance<T>;
4064	fn div(self, rhs: &Elastance<T>) -> Self::Output {
4065		Capacitance{F: T::from(self) / rhs.per_F.clone()}
4066	}
4067}
4068/// Dividing a scalar value by a Elastance unit value returns a value of type Capacitance
4069#[cfg(feature="num-complex")]
4070impl<T> core::ops::Div<&Elastance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4071	type Output = Capacitance<T>;
4072	fn div(self, rhs: &Elastance<T>) -> Self::Output {
4073		Capacitance{F: T::from(self.clone()) / rhs.per_F.clone()}
4074	}
4075}
4076
4077/// The illuminance unit type, defined as lux in SI units
4078#[derive(UnitStruct, Debug, Clone)]
4079#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
4080pub struct Illuminance<T: NumLike>{
4081	/// The value of this Illuminance in lux
4082	pub lux: T
4083}
4084
4085impl<T> Illuminance<T> where T: NumLike {
4086
4087	/// Returns the standard unit name of illuminance: "lux"
4088	pub fn unit_name() -> &'static str { "lux" }
4089	
4090	/// Returns the abbreviated name or symbol of illuminance: "lux" for lux
4091	pub fn unit_symbol() -> &'static str { "lux" }
4092	
4093	/// Returns a new illuminance value from the given number of lux
4094	///
4095	/// # Arguments
4096	/// * `lux` - Any number-like type, representing a quantity of lux
4097	pub fn from_lux(lux: T) -> Self { Illuminance{lux: lux} }
4098	
4099	/// Returns a copy of this illuminance value in lux
4100	pub fn to_lux(&self) -> T { self.lux.clone() }
4101
4102}
4103
4104impl<T> fmt::Display for Illuminance<T> where T: NumLike {
4105	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4106		write!(f, "{} {}", &self.lux, Self::unit_symbol())
4107	}
4108}
4109
4110impl<T> Illuminance<T> where T: NumLike+From<f64> {
4111	
4112	/// Returns a copy of this illuminance value in millilux
4113	/// 
4114	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4115	pub fn to_mlux(&self) -> T {
4116		return self.lux.clone() * T::from(1000.0_f64);
4117	}
4118
4119	/// Returns a new illuminance value from the given number of millilux
4120	/// 
4121	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4122	///
4123	/// # Arguments
4124	/// * `mlux` - Any number-like type, representing a quantity of millilux
4125	pub fn from_mlux(mlux: T) -> Self {
4126		Illuminance{lux: mlux * T::from(0.001_f64)}
4127	}
4128
4129	/// Returns a copy of this illuminance value in microlux
4130	/// 
4131	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4132	pub fn to_ulux(&self) -> T {
4133		return self.lux.clone() * T::from(1000000.0_f64);
4134	}
4135
4136	/// Returns a new illuminance value from the given number of microlux
4137	/// 
4138	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4139	///
4140	/// # Arguments
4141	/// * `ulux` - Any number-like type, representing a quantity of microlux
4142	pub fn from_ulux(ulux: T) -> Self {
4143		Illuminance{lux: ulux * T::from(1e-06_f64)}
4144	}
4145
4146	/// Returns a copy of this illuminance value in nanolux
4147	/// 
4148	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4149	pub fn to_nlux(&self) -> T {
4150		return self.lux.clone() * T::from(1000000000.0_f64);
4151	}
4152
4153	/// Returns a new illuminance value from the given number of nanolux
4154	/// 
4155	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4156	///
4157	/// # Arguments
4158	/// * `nlux` - Any number-like type, representing a quantity of nanolux
4159	pub fn from_nlux(nlux: T) -> Self {
4160		Illuminance{lux: nlux * T::from(1e-09_f64)}
4161	}
4162
4163	/// Returns a copy of this illuminance value in kilolux
4164	/// 
4165	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4166	pub fn to_klux(&self) -> T {
4167		return self.lux.clone() * T::from(0.001_f64);
4168	}
4169
4170	/// Returns a new illuminance value from the given number of kilolux
4171	/// 
4172	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4173	///
4174	/// # Arguments
4175	/// * `klux` - Any number-like type, representing a quantity of kilolux
4176	pub fn from_klux(klux: T) -> Self {
4177		Illuminance{lux: klux * T::from(1000.0_f64)}
4178	}
4179
4180	/// Returns a copy of this illuminance value in megalux
4181	/// 
4182	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4183	pub fn to_Mlux(&self) -> T {
4184		return self.lux.clone() * T::from(1e-06_f64);
4185	}
4186
4187	/// Returns a new illuminance value from the given number of megalux
4188	/// 
4189	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4190	///
4191	/// # Arguments
4192	/// * `Mlux` - Any number-like type, representing a quantity of megalux
4193	pub fn from_Mlux(Mlux: T) -> Self {
4194		Illuminance{lux: Mlux * T::from(1000000.0_f64)}
4195	}
4196
4197	/// Returns a copy of this illuminance value in gigalux
4198	/// 
4199	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4200	pub fn to_Glux(&self) -> T {
4201		return self.lux.clone() * T::from(1e-09_f64);
4202	}
4203
4204	/// Returns a new illuminance value from the given number of gigalux
4205	/// 
4206	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4207	///
4208	/// # Arguments
4209	/// * `Glux` - Any number-like type, representing a quantity of gigalux
4210	pub fn from_Glux(Glux: T) -> Self {
4211		Illuminance{lux: Glux * T::from(1000000000.0_f64)}
4212	}
4213
4214}
4215
4216
4217/// Multiplying a unit value by a scalar value returns a unit value
4218#[cfg(feature="num-bigfloat")]
4219impl core::ops::Mul<Illuminance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
4220	type Output = Illuminance<num_bigfloat::BigFloat>;
4221	fn mul(self, rhs: Illuminance<num_bigfloat::BigFloat>) -> Self::Output {
4222		Illuminance{lux: self * rhs.lux}
4223	}
4224}
4225/// Multiplying a unit value by a scalar value returns a unit value
4226#[cfg(feature="num-bigfloat")]
4227impl core::ops::Mul<Illuminance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
4228	type Output = Illuminance<num_bigfloat::BigFloat>;
4229	fn mul(self, rhs: Illuminance<num_bigfloat::BigFloat>) -> Self::Output {
4230		Illuminance{lux: self.clone() * rhs.lux}
4231	}
4232}
4233/// Multiplying a unit value by a scalar value returns a unit value
4234#[cfg(feature="num-bigfloat")]
4235impl core::ops::Mul<&Illuminance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
4236	type Output = Illuminance<num_bigfloat::BigFloat>;
4237	fn mul(self, rhs: &Illuminance<num_bigfloat::BigFloat>) -> Self::Output {
4238		Illuminance{lux: self * rhs.lux.clone()}
4239	}
4240}
4241/// Multiplying a unit value by a scalar value returns a unit value
4242#[cfg(feature="num-bigfloat")]
4243impl core::ops::Mul<&Illuminance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
4244	type Output = Illuminance<num_bigfloat::BigFloat>;
4245	fn mul(self, rhs: &Illuminance<num_bigfloat::BigFloat>) -> Self::Output {
4246		Illuminance{lux: self.clone() * rhs.lux.clone()}
4247	}
4248}
4249
4250/// Multiplying a unit value by a scalar value returns a unit value
4251#[cfg(feature="num-complex")]
4252impl core::ops::Mul<Illuminance<num_complex::Complex32>> for num_complex::Complex32 {
4253	type Output = Illuminance<num_complex::Complex32>;
4254	fn mul(self, rhs: Illuminance<num_complex::Complex32>) -> Self::Output {
4255		Illuminance{lux: self * rhs.lux}
4256	}
4257}
4258/// Multiplying a unit value by a scalar value returns a unit value
4259#[cfg(feature="num-complex")]
4260impl core::ops::Mul<Illuminance<num_complex::Complex32>> for &num_complex::Complex32 {
4261	type Output = Illuminance<num_complex::Complex32>;
4262	fn mul(self, rhs: Illuminance<num_complex::Complex32>) -> Self::Output {
4263		Illuminance{lux: self.clone() * rhs.lux}
4264	}
4265}
4266/// Multiplying a unit value by a scalar value returns a unit value
4267#[cfg(feature="num-complex")]
4268impl core::ops::Mul<&Illuminance<num_complex::Complex32>> for num_complex::Complex32 {
4269	type Output = Illuminance<num_complex::Complex32>;
4270	fn mul(self, rhs: &Illuminance<num_complex::Complex32>) -> Self::Output {
4271		Illuminance{lux: self * rhs.lux.clone()}
4272	}
4273}
4274/// Multiplying a unit value by a scalar value returns a unit value
4275#[cfg(feature="num-complex")]
4276impl core::ops::Mul<&Illuminance<num_complex::Complex32>> for &num_complex::Complex32 {
4277	type Output = Illuminance<num_complex::Complex32>;
4278	fn mul(self, rhs: &Illuminance<num_complex::Complex32>) -> Self::Output {
4279		Illuminance{lux: self.clone() * rhs.lux.clone()}
4280	}
4281}
4282
4283/// Multiplying a unit value by a scalar value returns a unit value
4284#[cfg(feature="num-complex")]
4285impl core::ops::Mul<Illuminance<num_complex::Complex64>> for num_complex::Complex64 {
4286	type Output = Illuminance<num_complex::Complex64>;
4287	fn mul(self, rhs: Illuminance<num_complex::Complex64>) -> Self::Output {
4288		Illuminance{lux: self * rhs.lux}
4289	}
4290}
4291/// Multiplying a unit value by a scalar value returns a unit value
4292#[cfg(feature="num-complex")]
4293impl core::ops::Mul<Illuminance<num_complex::Complex64>> for &num_complex::Complex64 {
4294	type Output = Illuminance<num_complex::Complex64>;
4295	fn mul(self, rhs: Illuminance<num_complex::Complex64>) -> Self::Output {
4296		Illuminance{lux: self.clone() * rhs.lux}
4297	}
4298}
4299/// Multiplying a unit value by a scalar value returns a unit value
4300#[cfg(feature="num-complex")]
4301impl core::ops::Mul<&Illuminance<num_complex::Complex64>> for num_complex::Complex64 {
4302	type Output = Illuminance<num_complex::Complex64>;
4303	fn mul(self, rhs: &Illuminance<num_complex::Complex64>) -> Self::Output {
4304		Illuminance{lux: self * rhs.lux.clone()}
4305	}
4306}
4307/// Multiplying a unit value by a scalar value returns a unit value
4308#[cfg(feature="num-complex")]
4309impl core::ops::Mul<&Illuminance<num_complex::Complex64>> for &num_complex::Complex64 {
4310	type Output = Illuminance<num_complex::Complex64>;
4311	fn mul(self, rhs: &Illuminance<num_complex::Complex64>) -> Self::Output {
4312		Illuminance{lux: self.clone() * rhs.lux.clone()}
4313	}
4314}
4315
4316
4317
4318/// Converts a Illuminance into the equivalent [uom](https://crates.io/crates/uom) type [Luminance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Luminance.html)
4319#[cfg(feature = "uom")]
4320impl<T> Into<uom::si::f32::Luminance> for Illuminance<T> where T: NumLike+Into<f32> {
4321	fn into(self) -> uom::si::f32::Luminance {
4322		uom::si::f32::Luminance::new::<uom::si::luminance::candela_per_square_meter>(self.lux.into())
4323	}
4324}
4325
4326/// Creates a Illuminance from the equivalent [uom](https://crates.io/crates/uom) type [Luminance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Luminance.html)
4327#[cfg(feature = "uom")]
4328impl<T> From<uom::si::f32::Luminance> for Illuminance<T> where T: NumLike+From<f32> {
4329	fn from(src: uom::si::f32::Luminance) -> Self {
4330		Illuminance{lux: T::from(src.value)}
4331	}
4332}
4333
4334/// Converts a Illuminance into the equivalent [uom](https://crates.io/crates/uom) type [Luminance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Luminance.html)
4335#[cfg(feature = "uom")]
4336impl<T> Into<uom::si::f64::Luminance> for Illuminance<T> where T: NumLike+Into<f64> {
4337	fn into(self) -> uom::si::f64::Luminance {
4338		uom::si::f64::Luminance::new::<uom::si::luminance::candela_per_square_meter>(self.lux.into())
4339	}
4340}
4341
4342/// Creates a Illuminance from the equivalent [uom](https://crates.io/crates/uom) type [Luminance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Luminance.html)
4343#[cfg(feature = "uom")]
4344impl<T> From<uom::si::f64::Luminance> for Illuminance<T> where T: NumLike+From<f64> {
4345	fn from(src: uom::si::f64::Luminance) -> Self {
4346		Illuminance{lux: T::from(src.value)}
4347	}
4348}
4349
4350
4351// Illuminance * InverseLuminousFlux -> InverseArea
4352/// Multiplying a Illuminance by a InverseLuminousFlux returns a value of type InverseArea
4353impl<T> core::ops::Mul<InverseLuminousFlux<T>> for Illuminance<T> where T: NumLike {
4354	type Output = InverseArea<T>;
4355	fn mul(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
4356		InverseArea{per_m2: self.lux * rhs.per_lm}
4357	}
4358}
4359/// Multiplying a Illuminance by a InverseLuminousFlux returns a value of type InverseArea
4360impl<T> core::ops::Mul<InverseLuminousFlux<T>> for &Illuminance<T> where T: NumLike {
4361	type Output = InverseArea<T>;
4362	fn mul(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
4363		InverseArea{per_m2: self.lux.clone() * rhs.per_lm}
4364	}
4365}
4366/// Multiplying a Illuminance by a InverseLuminousFlux returns a value of type InverseArea
4367impl<T> core::ops::Mul<&InverseLuminousFlux<T>> for Illuminance<T> where T: NumLike {
4368	type Output = InverseArea<T>;
4369	fn mul(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
4370		InverseArea{per_m2: self.lux * rhs.per_lm.clone()}
4371	}
4372}
4373/// Multiplying a Illuminance by a InverseLuminousFlux returns a value of type InverseArea
4374impl<T> core::ops::Mul<&InverseLuminousFlux<T>> for &Illuminance<T> where T: NumLike {
4375	type Output = InverseArea<T>;
4376	fn mul(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
4377		InverseArea{per_m2: self.lux.clone() * rhs.per_lm.clone()}
4378	}
4379}
4380
4381// Illuminance / LuminousFlux -> InverseArea
4382/// Dividing a Illuminance by a LuminousFlux returns a value of type InverseArea
4383impl<T> core::ops::Div<LuminousFlux<T>> for Illuminance<T> where T: NumLike {
4384	type Output = InverseArea<T>;
4385	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
4386		InverseArea{per_m2: self.lux / rhs.lm}
4387	}
4388}
4389/// Dividing a Illuminance by a LuminousFlux returns a value of type InverseArea
4390impl<T> core::ops::Div<LuminousFlux<T>> for &Illuminance<T> where T: NumLike {
4391	type Output = InverseArea<T>;
4392	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
4393		InverseArea{per_m2: self.lux.clone() / rhs.lm}
4394	}
4395}
4396/// Dividing a Illuminance by a LuminousFlux returns a value of type InverseArea
4397impl<T> core::ops::Div<&LuminousFlux<T>> for Illuminance<T> where T: NumLike {
4398	type Output = InverseArea<T>;
4399	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
4400		InverseArea{per_m2: self.lux / rhs.lm.clone()}
4401	}
4402}
4403/// Dividing a Illuminance by a LuminousFlux returns a value of type InverseArea
4404impl<T> core::ops::Div<&LuminousFlux<T>> for &Illuminance<T> where T: NumLike {
4405	type Output = InverseArea<T>;
4406	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
4407		InverseArea{per_m2: self.lux.clone() / rhs.lm.clone()}
4408	}
4409}
4410
4411// Illuminance * Area -> LuminousFlux
4412/// Multiplying a Illuminance by a Area returns a value of type LuminousFlux
4413impl<T> core::ops::Mul<Area<T>> for Illuminance<T> where T: NumLike {
4414	type Output = LuminousFlux<T>;
4415	fn mul(self, rhs: Area<T>) -> Self::Output {
4416		LuminousFlux{lm: self.lux * rhs.m2}
4417	}
4418}
4419/// Multiplying a Illuminance by a Area returns a value of type LuminousFlux
4420impl<T> core::ops::Mul<Area<T>> for &Illuminance<T> where T: NumLike {
4421	type Output = LuminousFlux<T>;
4422	fn mul(self, rhs: Area<T>) -> Self::Output {
4423		LuminousFlux{lm: self.lux.clone() * rhs.m2}
4424	}
4425}
4426/// Multiplying a Illuminance by a Area returns a value of type LuminousFlux
4427impl<T> core::ops::Mul<&Area<T>> for Illuminance<T> where T: NumLike {
4428	type Output = LuminousFlux<T>;
4429	fn mul(self, rhs: &Area<T>) -> Self::Output {
4430		LuminousFlux{lm: self.lux * rhs.m2.clone()}
4431	}
4432}
4433/// Multiplying a Illuminance by a Area returns a value of type LuminousFlux
4434impl<T> core::ops::Mul<&Area<T>> for &Illuminance<T> where T: NumLike {
4435	type Output = LuminousFlux<T>;
4436	fn mul(self, rhs: &Area<T>) -> Self::Output {
4437		LuminousFlux{lm: self.lux.clone() * rhs.m2.clone()}
4438	}
4439}
4440
4441// Illuminance / InverseArea -> LuminousFlux
4442/// Dividing a Illuminance by a InverseArea returns a value of type LuminousFlux
4443impl<T> core::ops::Div<InverseArea<T>> for Illuminance<T> where T: NumLike {
4444	type Output = LuminousFlux<T>;
4445	fn div(self, rhs: InverseArea<T>) -> Self::Output {
4446		LuminousFlux{lm: self.lux / rhs.per_m2}
4447	}
4448}
4449/// Dividing a Illuminance by a InverseArea returns a value of type LuminousFlux
4450impl<T> core::ops::Div<InverseArea<T>> for &Illuminance<T> where T: NumLike {
4451	type Output = LuminousFlux<T>;
4452	fn div(self, rhs: InverseArea<T>) -> Self::Output {
4453		LuminousFlux{lm: self.lux.clone() / rhs.per_m2}
4454	}
4455}
4456/// Dividing a Illuminance by a InverseArea returns a value of type LuminousFlux
4457impl<T> core::ops::Div<&InverseArea<T>> for Illuminance<T> where T: NumLike {
4458	type Output = LuminousFlux<T>;
4459	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
4460		LuminousFlux{lm: self.lux / rhs.per_m2.clone()}
4461	}
4462}
4463/// Dividing a Illuminance by a InverseArea returns a value of type LuminousFlux
4464impl<T> core::ops::Div<&InverseArea<T>> for &Illuminance<T> where T: NumLike {
4465	type Output = LuminousFlux<T>;
4466	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
4467		LuminousFlux{lm: self.lux.clone() / rhs.per_m2.clone()}
4468	}
4469}
4470
4471// 1/Illuminance -> AreaPerLumen
4472/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4473impl<T> core::ops::Div<Illuminance<T>> for f64 where T: NumLike+From<f64> {
4474	type Output = AreaPerLumen<T>;
4475	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4476		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4477	}
4478}
4479/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4480impl<T> core::ops::Div<Illuminance<T>> for &f64 where T: NumLike+From<f64> {
4481	type Output = AreaPerLumen<T>;
4482	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4483		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4484	}
4485}
4486/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4487impl<T> core::ops::Div<&Illuminance<T>> for f64 where T: NumLike+From<f64> {
4488	type Output = AreaPerLumen<T>;
4489	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4490		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4491	}
4492}
4493/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4494impl<T> core::ops::Div<&Illuminance<T>> for &f64 where T: NumLike+From<f64> {
4495	type Output = AreaPerLumen<T>;
4496	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4497		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4498	}
4499}
4500
4501// 1/Illuminance -> AreaPerLumen
4502/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4503impl<T> core::ops::Div<Illuminance<T>> for f32 where T: NumLike+From<f32> {
4504	type Output = AreaPerLumen<T>;
4505	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4506		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4507	}
4508}
4509/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4510impl<T> core::ops::Div<Illuminance<T>> for &f32 where T: NumLike+From<f32> {
4511	type Output = AreaPerLumen<T>;
4512	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4513		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4514	}
4515}
4516/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4517impl<T> core::ops::Div<&Illuminance<T>> for f32 where T: NumLike+From<f32> {
4518	type Output = AreaPerLumen<T>;
4519	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4520		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4521	}
4522}
4523/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4524impl<T> core::ops::Div<&Illuminance<T>> for &f32 where T: NumLike+From<f32> {
4525	type Output = AreaPerLumen<T>;
4526	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4527		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4528	}
4529}
4530
4531// 1/Illuminance -> AreaPerLumen
4532/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4533impl<T> core::ops::Div<Illuminance<T>> for i64 where T: NumLike+From<i64> {
4534	type Output = AreaPerLumen<T>;
4535	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4536		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4537	}
4538}
4539/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4540impl<T> core::ops::Div<Illuminance<T>> for &i64 where T: NumLike+From<i64> {
4541	type Output = AreaPerLumen<T>;
4542	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4543		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4544	}
4545}
4546/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4547impl<T> core::ops::Div<&Illuminance<T>> for i64 where T: NumLike+From<i64> {
4548	type Output = AreaPerLumen<T>;
4549	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4550		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4551	}
4552}
4553/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4554impl<T> core::ops::Div<&Illuminance<T>> for &i64 where T: NumLike+From<i64> {
4555	type Output = AreaPerLumen<T>;
4556	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4557		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4558	}
4559}
4560
4561// 1/Illuminance -> AreaPerLumen
4562/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4563impl<T> core::ops::Div<Illuminance<T>> for i32 where T: NumLike+From<i32> {
4564	type Output = AreaPerLumen<T>;
4565	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4566		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4567	}
4568}
4569/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4570impl<T> core::ops::Div<Illuminance<T>> for &i32 where T: NumLike+From<i32> {
4571	type Output = AreaPerLumen<T>;
4572	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4573		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4574	}
4575}
4576/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4577impl<T> core::ops::Div<&Illuminance<T>> for i32 where T: NumLike+From<i32> {
4578	type Output = AreaPerLumen<T>;
4579	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4580		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4581	}
4582}
4583/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4584impl<T> core::ops::Div<&Illuminance<T>> for &i32 where T: NumLike+From<i32> {
4585	type Output = AreaPerLumen<T>;
4586	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4587		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4588	}
4589}
4590
4591// 1/Illuminance -> AreaPerLumen
4592/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4593#[cfg(feature="num-bigfloat")]
4594impl<T> core::ops::Div<Illuminance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
4595	type Output = AreaPerLumen<T>;
4596	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4597		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4598	}
4599}
4600/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4601#[cfg(feature="num-bigfloat")]
4602impl<T> core::ops::Div<Illuminance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
4603	type Output = AreaPerLumen<T>;
4604	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4605		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4606	}
4607}
4608/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4609#[cfg(feature="num-bigfloat")]
4610impl<T> core::ops::Div<&Illuminance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
4611	type Output = AreaPerLumen<T>;
4612	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4613		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4614	}
4615}
4616/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4617#[cfg(feature="num-bigfloat")]
4618impl<T> core::ops::Div<&Illuminance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
4619	type Output = AreaPerLumen<T>;
4620	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4621		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4622	}
4623}
4624
4625// 1/Illuminance -> AreaPerLumen
4626/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4627#[cfg(feature="num-complex")]
4628impl<T> core::ops::Div<Illuminance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4629	type Output = AreaPerLumen<T>;
4630	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4631		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4632	}
4633}
4634/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4635#[cfg(feature="num-complex")]
4636impl<T> core::ops::Div<Illuminance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4637	type Output = AreaPerLumen<T>;
4638	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4639		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4640	}
4641}
4642/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4643#[cfg(feature="num-complex")]
4644impl<T> core::ops::Div<&Illuminance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4645	type Output = AreaPerLumen<T>;
4646	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4647		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4648	}
4649}
4650/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4651#[cfg(feature="num-complex")]
4652impl<T> core::ops::Div<&Illuminance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
4653	type Output = AreaPerLumen<T>;
4654	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4655		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4656	}
4657}
4658
4659// 1/Illuminance -> AreaPerLumen
4660/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4661#[cfg(feature="num-complex")]
4662impl<T> core::ops::Div<Illuminance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4663	type Output = AreaPerLumen<T>;
4664	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4665		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux}
4666	}
4667}
4668/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4669#[cfg(feature="num-complex")]
4670impl<T> core::ops::Div<Illuminance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4671	type Output = AreaPerLumen<T>;
4672	fn div(self, rhs: Illuminance<T>) -> Self::Output {
4673		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux}
4674	}
4675}
4676/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4677#[cfg(feature="num-complex")]
4678impl<T> core::ops::Div<&Illuminance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4679	type Output = AreaPerLumen<T>;
4680	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4681		AreaPerLumen{m2_per_lm: T::from(self) / rhs.lux.clone()}
4682	}
4683}
4684/// Dividing a scalar value by a Illuminance unit value returns a value of type AreaPerLumen
4685#[cfg(feature="num-complex")]
4686impl<T> core::ops::Div<&Illuminance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
4687	type Output = AreaPerLumen<T>;
4688	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
4689		AreaPerLumen{m2_per_lm: T::from(self.clone()) / rhs.lux.clone()}
4690	}
4691}
4692
4693/// The inductance unit type, defined as henries in SI units
4694#[derive(UnitStruct, Debug, Clone)]
4695#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
4696pub struct Inductance<T: NumLike>{
4697	/// The value of this Inductance in henries
4698	pub H: T
4699}
4700
4701impl<T> Inductance<T> where T: NumLike {
4702
4703	/// Returns the standard unit name of inductance: "henries"
4704	pub fn unit_name() -> &'static str { "henries" }
4705	
4706	/// Returns the abbreviated name or symbol of inductance: "H" for henries
4707	pub fn unit_symbol() -> &'static str { "H" }
4708	
4709	/// Returns a new inductance value from the given number of henries
4710	///
4711	/// # Arguments
4712	/// * `H` - Any number-like type, representing a quantity of henries
4713	pub fn from_H(H: T) -> Self { Inductance{H: H} }
4714	
4715	/// Returns a copy of this inductance value in henries
4716	pub fn to_H(&self) -> T { self.H.clone() }
4717
4718	/// Returns a new inductance value from the given number of henries
4719	///
4720	/// # Arguments
4721	/// * `henries` - Any number-like type, representing a quantity of henries
4722	pub fn from_henries(henries: T) -> Self { Inductance{H: henries} }
4723	
4724	/// Returns a copy of this inductance value in henries
4725	pub fn to_henries(&self) -> T { self.H.clone() }
4726
4727}
4728
4729impl<T> fmt::Display for Inductance<T> where T: NumLike {
4730	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4731		write!(f, "{} {}", &self.H, Self::unit_symbol())
4732	}
4733}
4734
4735impl<T> Inductance<T> where T: NumLike+From<f64> {
4736	
4737	/// Returns a copy of this inductance value in millihenries
4738	/// 
4739	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4740	pub fn to_mH(&self) -> T {
4741		return self.H.clone() * T::from(1000.0_f64);
4742	}
4743
4744	/// Returns a new inductance value from the given number of millihenries
4745	/// 
4746	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4747	///
4748	/// # Arguments
4749	/// * `mH` - Any number-like type, representing a quantity of millihenries
4750	pub fn from_mH(mH: T) -> Self {
4751		Inductance{H: mH * T::from(0.001_f64)}
4752	}
4753
4754	/// Returns a copy of this inductance value in microhenries
4755	/// 
4756	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4757	pub fn to_uH(&self) -> T {
4758		return self.H.clone() * T::from(1000000.0_f64);
4759	}
4760
4761	/// Returns a new inductance value from the given number of microhenries
4762	/// 
4763	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4764	///
4765	/// # Arguments
4766	/// * `uH` - Any number-like type, representing a quantity of microhenries
4767	pub fn from_uH(uH: T) -> Self {
4768		Inductance{H: uH * T::from(1e-06_f64)}
4769	}
4770
4771	/// Returns a copy of this inductance value in nanohenries
4772	/// 
4773	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4774	pub fn to_nH(&self) -> T {
4775		return self.H.clone() * T::from(1000000000.0_f64);
4776	}
4777
4778	/// Returns a new inductance value from the given number of nanohenries
4779	/// 
4780	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4781	///
4782	/// # Arguments
4783	/// * `nH` - Any number-like type, representing a quantity of nanohenries
4784	pub fn from_nH(nH: T) -> Self {
4785		Inductance{H: nH * T::from(1e-09_f64)}
4786	}
4787
4788	/// Returns a copy of this inductance value in kilohenries
4789	/// 
4790	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4791	pub fn to_kH(&self) -> T {
4792		return self.H.clone() * T::from(0.001_f64);
4793	}
4794
4795	/// Returns a new inductance value from the given number of kilohenries
4796	/// 
4797	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4798	///
4799	/// # Arguments
4800	/// * `kH` - Any number-like type, representing a quantity of kilohenries
4801	pub fn from_kH(kH: T) -> Self {
4802		Inductance{H: kH * T::from(1000.0_f64)}
4803	}
4804
4805	/// Returns a copy of this inductance value in megahenries
4806	/// 
4807	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4808	pub fn to_MH(&self) -> T {
4809		return self.H.clone() * T::from(1e-06_f64);
4810	}
4811
4812	/// Returns a new inductance value from the given number of megahenries
4813	/// 
4814	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4815	///
4816	/// # Arguments
4817	/// * `MH` - Any number-like type, representing a quantity of megahenries
4818	pub fn from_MH(MH: T) -> Self {
4819		Inductance{H: MH * T::from(1000000.0_f64)}
4820	}
4821
4822	/// Returns a copy of this inductance value in gigahenries
4823	/// 
4824	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4825	pub fn to_GH(&self) -> T {
4826		return self.H.clone() * T::from(1e-09_f64);
4827	}
4828
4829	/// Returns a new inductance value from the given number of gigahenries
4830	/// 
4831	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
4832	///
4833	/// # Arguments
4834	/// * `GH` - Any number-like type, representing a quantity of gigahenries
4835	pub fn from_GH(GH: T) -> Self {
4836		Inductance{H: GH * T::from(1000000000.0_f64)}
4837	}
4838
4839}
4840
4841
4842/// Multiplying a unit value by a scalar value returns a unit value
4843#[cfg(feature="num-bigfloat")]
4844impl core::ops::Mul<Inductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
4845	type Output = Inductance<num_bigfloat::BigFloat>;
4846	fn mul(self, rhs: Inductance<num_bigfloat::BigFloat>) -> Self::Output {
4847		Inductance{H: self * rhs.H}
4848	}
4849}
4850/// Multiplying a unit value by a scalar value returns a unit value
4851#[cfg(feature="num-bigfloat")]
4852impl core::ops::Mul<Inductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
4853	type Output = Inductance<num_bigfloat::BigFloat>;
4854	fn mul(self, rhs: Inductance<num_bigfloat::BigFloat>) -> Self::Output {
4855		Inductance{H: self.clone() * rhs.H}
4856	}
4857}
4858/// Multiplying a unit value by a scalar value returns a unit value
4859#[cfg(feature="num-bigfloat")]
4860impl core::ops::Mul<&Inductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
4861	type Output = Inductance<num_bigfloat::BigFloat>;
4862	fn mul(self, rhs: &Inductance<num_bigfloat::BigFloat>) -> Self::Output {
4863		Inductance{H: self * rhs.H.clone()}
4864	}
4865}
4866/// Multiplying a unit value by a scalar value returns a unit value
4867#[cfg(feature="num-bigfloat")]
4868impl core::ops::Mul<&Inductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
4869	type Output = Inductance<num_bigfloat::BigFloat>;
4870	fn mul(self, rhs: &Inductance<num_bigfloat::BigFloat>) -> Self::Output {
4871		Inductance{H: self.clone() * rhs.H.clone()}
4872	}
4873}
4874
4875/// Multiplying a unit value by a scalar value returns a unit value
4876#[cfg(feature="num-complex")]
4877impl core::ops::Mul<Inductance<num_complex::Complex32>> for num_complex::Complex32 {
4878	type Output = Inductance<num_complex::Complex32>;
4879	fn mul(self, rhs: Inductance<num_complex::Complex32>) -> Self::Output {
4880		Inductance{H: self * rhs.H}
4881	}
4882}
4883/// Multiplying a unit value by a scalar value returns a unit value
4884#[cfg(feature="num-complex")]
4885impl core::ops::Mul<Inductance<num_complex::Complex32>> for &num_complex::Complex32 {
4886	type Output = Inductance<num_complex::Complex32>;
4887	fn mul(self, rhs: Inductance<num_complex::Complex32>) -> Self::Output {
4888		Inductance{H: self.clone() * rhs.H}
4889	}
4890}
4891/// Multiplying a unit value by a scalar value returns a unit value
4892#[cfg(feature="num-complex")]
4893impl core::ops::Mul<&Inductance<num_complex::Complex32>> for num_complex::Complex32 {
4894	type Output = Inductance<num_complex::Complex32>;
4895	fn mul(self, rhs: &Inductance<num_complex::Complex32>) -> Self::Output {
4896		Inductance{H: self * rhs.H.clone()}
4897	}
4898}
4899/// Multiplying a unit value by a scalar value returns a unit value
4900#[cfg(feature="num-complex")]
4901impl core::ops::Mul<&Inductance<num_complex::Complex32>> for &num_complex::Complex32 {
4902	type Output = Inductance<num_complex::Complex32>;
4903	fn mul(self, rhs: &Inductance<num_complex::Complex32>) -> Self::Output {
4904		Inductance{H: self.clone() * rhs.H.clone()}
4905	}
4906}
4907
4908/// Multiplying a unit value by a scalar value returns a unit value
4909#[cfg(feature="num-complex")]
4910impl core::ops::Mul<Inductance<num_complex::Complex64>> for num_complex::Complex64 {
4911	type Output = Inductance<num_complex::Complex64>;
4912	fn mul(self, rhs: Inductance<num_complex::Complex64>) -> Self::Output {
4913		Inductance{H: self * rhs.H}
4914	}
4915}
4916/// Multiplying a unit value by a scalar value returns a unit value
4917#[cfg(feature="num-complex")]
4918impl core::ops::Mul<Inductance<num_complex::Complex64>> for &num_complex::Complex64 {
4919	type Output = Inductance<num_complex::Complex64>;
4920	fn mul(self, rhs: Inductance<num_complex::Complex64>) -> Self::Output {
4921		Inductance{H: self.clone() * rhs.H}
4922	}
4923}
4924/// Multiplying a unit value by a scalar value returns a unit value
4925#[cfg(feature="num-complex")]
4926impl core::ops::Mul<&Inductance<num_complex::Complex64>> for num_complex::Complex64 {
4927	type Output = Inductance<num_complex::Complex64>;
4928	fn mul(self, rhs: &Inductance<num_complex::Complex64>) -> Self::Output {
4929		Inductance{H: self * rhs.H.clone()}
4930	}
4931}
4932/// Multiplying a unit value by a scalar value returns a unit value
4933#[cfg(feature="num-complex")]
4934impl core::ops::Mul<&Inductance<num_complex::Complex64>> for &num_complex::Complex64 {
4935	type Output = Inductance<num_complex::Complex64>;
4936	fn mul(self, rhs: &Inductance<num_complex::Complex64>) -> Self::Output {
4937		Inductance{H: self.clone() * rhs.H.clone()}
4938	}
4939}
4940
4941
4942
4943/// Converts a Inductance into the equivalent [uom](https://crates.io/crates/uom) type [Inductance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Inductance.html)
4944#[cfg(feature = "uom")]
4945impl<T> Into<uom::si::f32::Inductance> for Inductance<T> where T: NumLike+Into<f32> {
4946	fn into(self) -> uom::si::f32::Inductance {
4947		uom::si::f32::Inductance::new::<uom::si::inductance::henry>(self.H.into())
4948	}
4949}
4950
4951/// Creates a Inductance from the equivalent [uom](https://crates.io/crates/uom) type [Inductance](https://docs.rs/uom/0.34.0/uom/si/f32/type.Inductance.html)
4952#[cfg(feature = "uom")]
4953impl<T> From<uom::si::f32::Inductance> for Inductance<T> where T: NumLike+From<f32> {
4954	fn from(src: uom::si::f32::Inductance) -> Self {
4955		Inductance{H: T::from(src.value)}
4956	}
4957}
4958
4959/// Converts a Inductance into the equivalent [uom](https://crates.io/crates/uom) type [Inductance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Inductance.html)
4960#[cfg(feature = "uom")]
4961impl<T> Into<uom::si::f64::Inductance> for Inductance<T> where T: NumLike+Into<f64> {
4962	fn into(self) -> uom::si::f64::Inductance {
4963		uom::si::f64::Inductance::new::<uom::si::inductance::henry>(self.H.into())
4964	}
4965}
4966
4967/// Creates a Inductance from the equivalent [uom](https://crates.io/crates/uom) type [Inductance](https://docs.rs/uom/0.34.0/uom/si/f64/type.Inductance.html)
4968#[cfg(feature = "uom")]
4969impl<T> From<uom::si::f64::Inductance> for Inductance<T> where T: NumLike+From<f64> {
4970	fn from(src: uom::si::f64::Inductance) -> Self {
4971		Inductance{H: T::from(src.value)}
4972	}
4973}
4974
4975
4976// Inductance * Current -> MagneticFlux
4977/// Multiplying a Inductance by a Current returns a value of type MagneticFlux
4978impl<T> core::ops::Mul<Current<T>> for Inductance<T> where T: NumLike {
4979	type Output = MagneticFlux<T>;
4980	fn mul(self, rhs: Current<T>) -> Self::Output {
4981		MagneticFlux{Wb: self.H * rhs.A}
4982	}
4983}
4984/// Multiplying a Inductance by a Current returns a value of type MagneticFlux
4985impl<T> core::ops::Mul<Current<T>> for &Inductance<T> where T: NumLike {
4986	type Output = MagneticFlux<T>;
4987	fn mul(self, rhs: Current<T>) -> Self::Output {
4988		MagneticFlux{Wb: self.H.clone() * rhs.A}
4989	}
4990}
4991/// Multiplying a Inductance by a Current returns a value of type MagneticFlux
4992impl<T> core::ops::Mul<&Current<T>> for Inductance<T> where T: NumLike {
4993	type Output = MagneticFlux<T>;
4994	fn mul(self, rhs: &Current<T>) -> Self::Output {
4995		MagneticFlux{Wb: self.H * rhs.A.clone()}
4996	}
4997}
4998/// Multiplying a Inductance by a Current returns a value of type MagneticFlux
4999impl<T> core::ops::Mul<&Current<T>> for &Inductance<T> where T: NumLike {
5000	type Output = MagneticFlux<T>;
5001	fn mul(self, rhs: &Current<T>) -> Self::Output {
5002		MagneticFlux{Wb: self.H.clone() * rhs.A.clone()}
5003	}
5004}
5005
5006// Inductance / InverseCurrent -> MagneticFlux
5007/// Dividing a Inductance by a InverseCurrent returns a value of type MagneticFlux
5008impl<T> core::ops::Div<InverseCurrent<T>> for Inductance<T> where T: NumLike {
5009	type Output = MagneticFlux<T>;
5010	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
5011		MagneticFlux{Wb: self.H / rhs.per_A}
5012	}
5013}
5014/// Dividing a Inductance by a InverseCurrent returns a value of type MagneticFlux
5015impl<T> core::ops::Div<InverseCurrent<T>> for &Inductance<T> where T: NumLike {
5016	type Output = MagneticFlux<T>;
5017	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
5018		MagneticFlux{Wb: self.H.clone() / rhs.per_A}
5019	}
5020}
5021/// Dividing a Inductance by a InverseCurrent returns a value of type MagneticFlux
5022impl<T> core::ops::Div<&InverseCurrent<T>> for Inductance<T> where T: NumLike {
5023	type Output = MagneticFlux<T>;
5024	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
5025		MagneticFlux{Wb: self.H / rhs.per_A.clone()}
5026	}
5027}
5028/// Dividing a Inductance by a InverseCurrent returns a value of type MagneticFlux
5029impl<T> core::ops::Div<&InverseCurrent<T>> for &Inductance<T> where T: NumLike {
5030	type Output = MagneticFlux<T>;
5031	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
5032		MagneticFlux{Wb: self.H.clone() / rhs.per_A.clone()}
5033	}
5034}
5035
5036// Inductance / Time -> Resistance
5037/// Dividing a Inductance by a Time returns a value of type Resistance
5038impl<T> core::ops::Div<Time<T>> for Inductance<T> where T: NumLike {
5039	type Output = Resistance<T>;
5040	fn div(self, rhs: Time<T>) -> Self::Output {
5041		Resistance{Ohm: self.H / rhs.s}
5042	}
5043}
5044/// Dividing a Inductance by a Time returns a value of type Resistance
5045impl<T> core::ops::Div<Time<T>> for &Inductance<T> where T: NumLike {
5046	type Output = Resistance<T>;
5047	fn div(self, rhs: Time<T>) -> Self::Output {
5048		Resistance{Ohm: self.H.clone() / rhs.s}
5049	}
5050}
5051/// Dividing a Inductance by a Time returns a value of type Resistance
5052impl<T> core::ops::Div<&Time<T>> for Inductance<T> where T: NumLike {
5053	type Output = Resistance<T>;
5054	fn div(self, rhs: &Time<T>) -> Self::Output {
5055		Resistance{Ohm: self.H / rhs.s.clone()}
5056	}
5057}
5058/// Dividing a Inductance by a Time returns a value of type Resistance
5059impl<T> core::ops::Div<&Time<T>> for &Inductance<T> where T: NumLike {
5060	type Output = Resistance<T>;
5061	fn div(self, rhs: &Time<T>) -> Self::Output {
5062		Resistance{Ohm: self.H.clone() / rhs.s.clone()}
5063	}
5064}
5065
5066// Inductance * Conductance -> Time
5067/// Multiplying a Inductance by a Conductance returns a value of type Time
5068impl<T> core::ops::Mul<Conductance<T>> for Inductance<T> where T: NumLike {
5069	type Output = Time<T>;
5070	fn mul(self, rhs: Conductance<T>) -> Self::Output {
5071		Time{s: self.H * rhs.S}
5072	}
5073}
5074/// Multiplying a Inductance by a Conductance returns a value of type Time
5075impl<T> core::ops::Mul<Conductance<T>> for &Inductance<T> where T: NumLike {
5076	type Output = Time<T>;
5077	fn mul(self, rhs: Conductance<T>) -> Self::Output {
5078		Time{s: self.H.clone() * rhs.S}
5079	}
5080}
5081/// Multiplying a Inductance by a Conductance returns a value of type Time
5082impl<T> core::ops::Mul<&Conductance<T>> for Inductance<T> where T: NumLike {
5083	type Output = Time<T>;
5084	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
5085		Time{s: self.H * rhs.S.clone()}
5086	}
5087}
5088/// Multiplying a Inductance by a Conductance returns a value of type Time
5089impl<T> core::ops::Mul<&Conductance<T>> for &Inductance<T> where T: NumLike {
5090	type Output = Time<T>;
5091	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
5092		Time{s: self.H.clone() * rhs.S.clone()}
5093	}
5094}
5095
5096// Inductance * InverseMagneticFlux -> InverseCurrent
5097/// Multiplying a Inductance by a InverseMagneticFlux returns a value of type InverseCurrent
5098impl<T> core::ops::Mul<InverseMagneticFlux<T>> for Inductance<T> where T: NumLike {
5099	type Output = InverseCurrent<T>;
5100	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
5101		InverseCurrent{per_A: self.H * rhs.per_Wb}
5102	}
5103}
5104/// Multiplying a Inductance by a InverseMagneticFlux returns a value of type InverseCurrent
5105impl<T> core::ops::Mul<InverseMagneticFlux<T>> for &Inductance<T> where T: NumLike {
5106	type Output = InverseCurrent<T>;
5107	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
5108		InverseCurrent{per_A: self.H.clone() * rhs.per_Wb}
5109	}
5110}
5111/// Multiplying a Inductance by a InverseMagneticFlux returns a value of type InverseCurrent
5112impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for Inductance<T> where T: NumLike {
5113	type Output = InverseCurrent<T>;
5114	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
5115		InverseCurrent{per_A: self.H * rhs.per_Wb.clone()}
5116	}
5117}
5118/// Multiplying a Inductance by a InverseMagneticFlux returns a value of type InverseCurrent
5119impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for &Inductance<T> where T: NumLike {
5120	type Output = InverseCurrent<T>;
5121	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
5122		InverseCurrent{per_A: self.H.clone() * rhs.per_Wb.clone()}
5123	}
5124}
5125
5126// Inductance / MagneticFlux -> InverseCurrent
5127/// Dividing a Inductance by a MagneticFlux returns a value of type InverseCurrent
5128impl<T> core::ops::Div<MagneticFlux<T>> for Inductance<T> where T: NumLike {
5129	type Output = InverseCurrent<T>;
5130	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
5131		InverseCurrent{per_A: self.H / rhs.Wb}
5132	}
5133}
5134/// Dividing a Inductance by a MagneticFlux returns a value of type InverseCurrent
5135impl<T> core::ops::Div<MagneticFlux<T>> for &Inductance<T> where T: NumLike {
5136	type Output = InverseCurrent<T>;
5137	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
5138		InverseCurrent{per_A: self.H.clone() / rhs.Wb}
5139	}
5140}
5141/// Dividing a Inductance by a MagneticFlux returns a value of type InverseCurrent
5142impl<T> core::ops::Div<&MagneticFlux<T>> for Inductance<T> where T: NumLike {
5143	type Output = InverseCurrent<T>;
5144	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
5145		InverseCurrent{per_A: self.H / rhs.Wb.clone()}
5146	}
5147}
5148/// Dividing a Inductance by a MagneticFlux returns a value of type InverseCurrent
5149impl<T> core::ops::Div<&MagneticFlux<T>> for &Inductance<T> where T: NumLike {
5150	type Output = InverseCurrent<T>;
5151	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
5152		InverseCurrent{per_A: self.H.clone() / rhs.Wb.clone()}
5153	}
5154}
5155
5156// Inductance / Resistance -> Time
5157/// Dividing a Inductance by a Resistance returns a value of type Time
5158impl<T> core::ops::Div<Resistance<T>> for Inductance<T> where T: NumLike {
5159	type Output = Time<T>;
5160	fn div(self, rhs: Resistance<T>) -> Self::Output {
5161		Time{s: self.H / rhs.Ohm}
5162	}
5163}
5164/// Dividing a Inductance by a Resistance returns a value of type Time
5165impl<T> core::ops::Div<Resistance<T>> for &Inductance<T> where T: NumLike {
5166	type Output = Time<T>;
5167	fn div(self, rhs: Resistance<T>) -> Self::Output {
5168		Time{s: self.H.clone() / rhs.Ohm}
5169	}
5170}
5171/// Dividing a Inductance by a Resistance returns a value of type Time
5172impl<T> core::ops::Div<&Resistance<T>> for Inductance<T> where T: NumLike {
5173	type Output = Time<T>;
5174	fn div(self, rhs: &Resistance<T>) -> Self::Output {
5175		Time{s: self.H / rhs.Ohm.clone()}
5176	}
5177}
5178/// Dividing a Inductance by a Resistance returns a value of type Time
5179impl<T> core::ops::Div<&Resistance<T>> for &Inductance<T> where T: NumLike {
5180	type Output = Time<T>;
5181	fn div(self, rhs: &Resistance<T>) -> Self::Output {
5182		Time{s: self.H.clone() / rhs.Ohm.clone()}
5183	}
5184}
5185
5186// Inductance * Frequency -> Resistance
5187/// Multiplying a Inductance by a Frequency returns a value of type Resistance
5188impl<T> core::ops::Mul<Frequency<T>> for Inductance<T> where T: NumLike {
5189	type Output = Resistance<T>;
5190	fn mul(self, rhs: Frequency<T>) -> Self::Output {
5191		Resistance{Ohm: self.H * rhs.Hz}
5192	}
5193}
5194/// Multiplying a Inductance by a Frequency returns a value of type Resistance
5195impl<T> core::ops::Mul<Frequency<T>> for &Inductance<T> where T: NumLike {
5196	type Output = Resistance<T>;
5197	fn mul(self, rhs: Frequency<T>) -> Self::Output {
5198		Resistance{Ohm: self.H.clone() * rhs.Hz}
5199	}
5200}
5201/// Multiplying a Inductance by a Frequency returns a value of type Resistance
5202impl<T> core::ops::Mul<&Frequency<T>> for Inductance<T> where T: NumLike {
5203	type Output = Resistance<T>;
5204	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
5205		Resistance{Ohm: self.H * rhs.Hz.clone()}
5206	}
5207}
5208/// Multiplying a Inductance by a Frequency returns a value of type Resistance
5209impl<T> core::ops::Mul<&Frequency<T>> for &Inductance<T> where T: NumLike {
5210	type Output = Resistance<T>;
5211	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
5212		Resistance{Ohm: self.H.clone() * rhs.Hz.clone()}
5213	}
5214}
5215
5216// 1/Inductance -> InverseInductance
5217/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5218impl<T> core::ops::Div<Inductance<T>> for f64 where T: NumLike+From<f64> {
5219	type Output = InverseInductance<T>;
5220	fn div(self, rhs: Inductance<T>) -> Self::Output {
5221		InverseInductance{per_H: T::from(self) / rhs.H}
5222	}
5223}
5224/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5225impl<T> core::ops::Div<Inductance<T>> for &f64 where T: NumLike+From<f64> {
5226	type Output = InverseInductance<T>;
5227	fn div(self, rhs: Inductance<T>) -> Self::Output {
5228		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5229	}
5230}
5231/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5232impl<T> core::ops::Div<&Inductance<T>> for f64 where T: NumLike+From<f64> {
5233	type Output = InverseInductance<T>;
5234	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5235		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5236	}
5237}
5238/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5239impl<T> core::ops::Div<&Inductance<T>> for &f64 where T: NumLike+From<f64> {
5240	type Output = InverseInductance<T>;
5241	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5242		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5243	}
5244}
5245
5246// 1/Inductance -> InverseInductance
5247/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5248impl<T> core::ops::Div<Inductance<T>> for f32 where T: NumLike+From<f32> {
5249	type Output = InverseInductance<T>;
5250	fn div(self, rhs: Inductance<T>) -> Self::Output {
5251		InverseInductance{per_H: T::from(self) / rhs.H}
5252	}
5253}
5254/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5255impl<T> core::ops::Div<Inductance<T>> for &f32 where T: NumLike+From<f32> {
5256	type Output = InverseInductance<T>;
5257	fn div(self, rhs: Inductance<T>) -> Self::Output {
5258		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5259	}
5260}
5261/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5262impl<T> core::ops::Div<&Inductance<T>> for f32 where T: NumLike+From<f32> {
5263	type Output = InverseInductance<T>;
5264	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5265		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5266	}
5267}
5268/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5269impl<T> core::ops::Div<&Inductance<T>> for &f32 where T: NumLike+From<f32> {
5270	type Output = InverseInductance<T>;
5271	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5272		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5273	}
5274}
5275
5276// 1/Inductance -> InverseInductance
5277/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5278impl<T> core::ops::Div<Inductance<T>> for i64 where T: NumLike+From<i64> {
5279	type Output = InverseInductance<T>;
5280	fn div(self, rhs: Inductance<T>) -> Self::Output {
5281		InverseInductance{per_H: T::from(self) / rhs.H}
5282	}
5283}
5284/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5285impl<T> core::ops::Div<Inductance<T>> for &i64 where T: NumLike+From<i64> {
5286	type Output = InverseInductance<T>;
5287	fn div(self, rhs: Inductance<T>) -> Self::Output {
5288		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5289	}
5290}
5291/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5292impl<T> core::ops::Div<&Inductance<T>> for i64 where T: NumLike+From<i64> {
5293	type Output = InverseInductance<T>;
5294	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5295		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5296	}
5297}
5298/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5299impl<T> core::ops::Div<&Inductance<T>> for &i64 where T: NumLike+From<i64> {
5300	type Output = InverseInductance<T>;
5301	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5302		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5303	}
5304}
5305
5306// 1/Inductance -> InverseInductance
5307/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5308impl<T> core::ops::Div<Inductance<T>> for i32 where T: NumLike+From<i32> {
5309	type Output = InverseInductance<T>;
5310	fn div(self, rhs: Inductance<T>) -> Self::Output {
5311		InverseInductance{per_H: T::from(self) / rhs.H}
5312	}
5313}
5314/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5315impl<T> core::ops::Div<Inductance<T>> for &i32 where T: NumLike+From<i32> {
5316	type Output = InverseInductance<T>;
5317	fn div(self, rhs: Inductance<T>) -> Self::Output {
5318		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5319	}
5320}
5321/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5322impl<T> core::ops::Div<&Inductance<T>> for i32 where T: NumLike+From<i32> {
5323	type Output = InverseInductance<T>;
5324	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5325		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5326	}
5327}
5328/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5329impl<T> core::ops::Div<&Inductance<T>> for &i32 where T: NumLike+From<i32> {
5330	type Output = InverseInductance<T>;
5331	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5332		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5333	}
5334}
5335
5336// 1/Inductance -> InverseInductance
5337/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5338#[cfg(feature="num-bigfloat")]
5339impl<T> core::ops::Div<Inductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
5340	type Output = InverseInductance<T>;
5341	fn div(self, rhs: Inductance<T>) -> Self::Output {
5342		InverseInductance{per_H: T::from(self) / rhs.H}
5343	}
5344}
5345/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5346#[cfg(feature="num-bigfloat")]
5347impl<T> core::ops::Div<Inductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
5348	type Output = InverseInductance<T>;
5349	fn div(self, rhs: Inductance<T>) -> Self::Output {
5350		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5351	}
5352}
5353/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5354#[cfg(feature="num-bigfloat")]
5355impl<T> core::ops::Div<&Inductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
5356	type Output = InverseInductance<T>;
5357	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5358		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5359	}
5360}
5361/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5362#[cfg(feature="num-bigfloat")]
5363impl<T> core::ops::Div<&Inductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
5364	type Output = InverseInductance<T>;
5365	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5366		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5367	}
5368}
5369
5370// 1/Inductance -> InverseInductance
5371/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5372#[cfg(feature="num-complex")]
5373impl<T> core::ops::Div<Inductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
5374	type Output = InverseInductance<T>;
5375	fn div(self, rhs: Inductance<T>) -> Self::Output {
5376		InverseInductance{per_H: T::from(self) / rhs.H}
5377	}
5378}
5379/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5380#[cfg(feature="num-complex")]
5381impl<T> core::ops::Div<Inductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
5382	type Output = InverseInductance<T>;
5383	fn div(self, rhs: Inductance<T>) -> Self::Output {
5384		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5385	}
5386}
5387/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5388#[cfg(feature="num-complex")]
5389impl<T> core::ops::Div<&Inductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
5390	type Output = InverseInductance<T>;
5391	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5392		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5393	}
5394}
5395/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5396#[cfg(feature="num-complex")]
5397impl<T> core::ops::Div<&Inductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
5398	type Output = InverseInductance<T>;
5399	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5400		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5401	}
5402}
5403
5404// 1/Inductance -> InverseInductance
5405/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5406#[cfg(feature="num-complex")]
5407impl<T> core::ops::Div<Inductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
5408	type Output = InverseInductance<T>;
5409	fn div(self, rhs: Inductance<T>) -> Self::Output {
5410		InverseInductance{per_H: T::from(self) / rhs.H}
5411	}
5412}
5413/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5414#[cfg(feature="num-complex")]
5415impl<T> core::ops::Div<Inductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
5416	type Output = InverseInductance<T>;
5417	fn div(self, rhs: Inductance<T>) -> Self::Output {
5418		InverseInductance{per_H: T::from(self.clone()) / rhs.H}
5419	}
5420}
5421/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5422#[cfg(feature="num-complex")]
5423impl<T> core::ops::Div<&Inductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
5424	type Output = InverseInductance<T>;
5425	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5426		InverseInductance{per_H: T::from(self) / rhs.H.clone()}
5427	}
5428}
5429/// Dividing a scalar value by a Inductance unit value returns a value of type InverseInductance
5430#[cfg(feature="num-complex")]
5431impl<T> core::ops::Div<&Inductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
5432	type Output = InverseInductance<T>;
5433	fn div(self, rhs: &Inductance<T>) -> Self::Output {
5434		InverseInductance{per_H: T::from(self.clone()) / rhs.H.clone()}
5435	}
5436}
5437
5438/// The inverse of electric charge (aka coulombs) unit type, defined as inverse coulombs in SI units
5439#[derive(UnitStruct, Debug, Clone)]
5440#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
5441pub struct InverseCharge<T: NumLike>{
5442	/// The value of this Inverse electric charge in inverse coulombs
5443	pub per_C: T
5444}
5445
5446impl<T> InverseCharge<T> where T: NumLike {
5447
5448	/// Returns the standard unit name of inverse electric charge: "inverse coulombs"
5449	pub fn unit_name() -> &'static str { "inverse coulombs" }
5450	
5451	/// Returns the abbreviated name or symbol of inverse electric charge: "1/C" for inverse coulombs
5452	pub fn unit_symbol() -> &'static str { "1/C" }
5453	
5454	/// Returns a new inverse electric charge value from the given number of inverse coulombs
5455	///
5456	/// # Arguments
5457	/// * `per_C` - Any number-like type, representing a quantity of inverse coulombs
5458	pub fn from_per_C(per_C: T) -> Self { InverseCharge{per_C: per_C} }
5459	
5460	/// Returns a copy of this inverse electric charge value in inverse coulombs
5461	pub fn to_per_C(&self) -> T { self.per_C.clone() }
5462
5463	/// Returns a new inverse electric charge value from the given number of inverse coulombs
5464	///
5465	/// # Arguments
5466	/// * `per_coulombs` - Any number-like type, representing a quantity of inverse coulombs
5467	pub fn from_per_coulombs(per_coulombs: T) -> Self { InverseCharge{per_C: per_coulombs} }
5468	
5469	/// Returns a copy of this inverse electric charge value in inverse coulombs
5470	pub fn to_per_coulombs(&self) -> T { self.per_C.clone() }
5471
5472}
5473
5474impl<T> fmt::Display for InverseCharge<T> where T: NumLike {
5475	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5476		write!(f, "{} {}", &self.per_C, Self::unit_symbol())
5477	}
5478}
5479
5480impl<T> InverseCharge<T> where T: NumLike+From<f64> {
5481	
5482	/// Returns a copy of this inverse electric charge value in inverse millicoulombs
5483	/// 
5484	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5485	pub fn to_per_mC(&self) -> T {
5486		return self.per_C.clone() * T::from(0.001_f64);
5487	}
5488
5489	/// Returns a new inverse electric charge value from the given number of inverse millicoulombs
5490	/// 
5491	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5492	///
5493	/// # Arguments
5494	/// * `per_mC` - Any number-like type, representing a quantity of inverse millicoulombs
5495	pub fn from_per_mC(per_mC: T) -> Self {
5496		InverseCharge{per_C: per_mC * T::from(1000.0_f64)}
5497	}
5498
5499	/// Returns a copy of this inverse electric charge value in inverse microcoulombs
5500	/// 
5501	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5502	pub fn to_per_uC(&self) -> T {
5503		return self.per_C.clone() * T::from(1e-06_f64);
5504	}
5505
5506	/// Returns a new inverse electric charge value from the given number of inverse microcoulombs
5507	/// 
5508	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5509	///
5510	/// # Arguments
5511	/// * `per_uC` - Any number-like type, representing a quantity of inverse microcoulombs
5512	pub fn from_per_uC(per_uC: T) -> Self {
5513		InverseCharge{per_C: per_uC * T::from(1000000.0_f64)}
5514	}
5515
5516	/// Returns a copy of this inverse electric charge value in inverse nanocoulombs
5517	/// 
5518	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5519	pub fn to_per_nC(&self) -> T {
5520		return self.per_C.clone() * T::from(1e-09_f64);
5521	}
5522
5523	/// Returns a new inverse electric charge value from the given number of inverse nanocoulombs
5524	/// 
5525	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5526	///
5527	/// # Arguments
5528	/// * `per_nC` - Any number-like type, representing a quantity of inverse nanocoulombs
5529	pub fn from_per_nC(per_nC: T) -> Self {
5530		InverseCharge{per_C: per_nC * T::from(1000000000.0_f64)}
5531	}
5532
5533	/// Returns a copy of this inverse electric charge value in inverse kilocoulombs
5534	/// 
5535	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5536	pub fn to_per_kC(&self) -> T {
5537		return self.per_C.clone() * T::from(1000.0_f64);
5538	}
5539
5540	/// Returns a new inverse electric charge value from the given number of inverse kilocoulombs
5541	/// 
5542	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5543	///
5544	/// # Arguments
5545	/// * `per_kC` - Any number-like type, representing a quantity of inverse kilocoulombs
5546	pub fn from_per_kC(per_kC: T) -> Self {
5547		InverseCharge{per_C: per_kC * T::from(0.001_f64)}
5548	}
5549
5550	/// Returns a copy of this inverse electric charge value in inverse megacoulombs
5551	/// 
5552	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5553	pub fn to_per_MC(&self) -> T {
5554		return self.per_C.clone() * T::from(1000000.0_f64);
5555	}
5556
5557	/// Returns a new inverse electric charge value from the given number of inverse megacoulombs
5558	/// 
5559	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5560	///
5561	/// # Arguments
5562	/// * `per_MC` - Any number-like type, representing a quantity of inverse megacoulombs
5563	pub fn from_per_MC(per_MC: T) -> Self {
5564		InverseCharge{per_C: per_MC * T::from(1e-06_f64)}
5565	}
5566
5567	/// Returns a copy of this inverse electric charge value in inverse gigacoulombs
5568	/// 
5569	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5570	pub fn to_per_GC(&self) -> T {
5571		return self.per_C.clone() * T::from(1000000000.0_f64);
5572	}
5573
5574	/// Returns a new inverse electric charge value from the given number of inverse gigacoulombs
5575	/// 
5576	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
5577	///
5578	/// # Arguments
5579	/// * `per_GC` - Any number-like type, representing a quantity of inverse gigacoulombs
5580	pub fn from_per_GC(per_GC: T) -> Self {
5581		InverseCharge{per_C: per_GC * T::from(1e-09_f64)}
5582	}
5583
5584}
5585
5586
5587/// Multiplying a unit value by a scalar value returns a unit value
5588#[cfg(feature="num-bigfloat")]
5589impl core::ops::Mul<InverseCharge<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
5590	type Output = InverseCharge<num_bigfloat::BigFloat>;
5591	fn mul(self, rhs: InverseCharge<num_bigfloat::BigFloat>) -> Self::Output {
5592		InverseCharge{per_C: self * rhs.per_C}
5593	}
5594}
5595/// Multiplying a unit value by a scalar value returns a unit value
5596#[cfg(feature="num-bigfloat")]
5597impl core::ops::Mul<InverseCharge<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
5598	type Output = InverseCharge<num_bigfloat::BigFloat>;
5599	fn mul(self, rhs: InverseCharge<num_bigfloat::BigFloat>) -> Self::Output {
5600		InverseCharge{per_C: self.clone() * rhs.per_C}
5601	}
5602}
5603/// Multiplying a unit value by a scalar value returns a unit value
5604#[cfg(feature="num-bigfloat")]
5605impl core::ops::Mul<&InverseCharge<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
5606	type Output = InverseCharge<num_bigfloat::BigFloat>;
5607	fn mul(self, rhs: &InverseCharge<num_bigfloat::BigFloat>) -> Self::Output {
5608		InverseCharge{per_C: self * rhs.per_C.clone()}
5609	}
5610}
5611/// Multiplying a unit value by a scalar value returns a unit value
5612#[cfg(feature="num-bigfloat")]
5613impl core::ops::Mul<&InverseCharge<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
5614	type Output = InverseCharge<num_bigfloat::BigFloat>;
5615	fn mul(self, rhs: &InverseCharge<num_bigfloat::BigFloat>) -> Self::Output {
5616		InverseCharge{per_C: self.clone() * rhs.per_C.clone()}
5617	}
5618}
5619
5620/// Multiplying a unit value by a scalar value returns a unit value
5621#[cfg(feature="num-complex")]
5622impl core::ops::Mul<InverseCharge<num_complex::Complex32>> for num_complex::Complex32 {
5623	type Output = InverseCharge<num_complex::Complex32>;
5624	fn mul(self, rhs: InverseCharge<num_complex::Complex32>) -> Self::Output {
5625		InverseCharge{per_C: self * rhs.per_C}
5626	}
5627}
5628/// Multiplying a unit value by a scalar value returns a unit value
5629#[cfg(feature="num-complex")]
5630impl core::ops::Mul<InverseCharge<num_complex::Complex32>> for &num_complex::Complex32 {
5631	type Output = InverseCharge<num_complex::Complex32>;
5632	fn mul(self, rhs: InverseCharge<num_complex::Complex32>) -> Self::Output {
5633		InverseCharge{per_C: self.clone() * rhs.per_C}
5634	}
5635}
5636/// Multiplying a unit value by a scalar value returns a unit value
5637#[cfg(feature="num-complex")]
5638impl core::ops::Mul<&InverseCharge<num_complex::Complex32>> for num_complex::Complex32 {
5639	type Output = InverseCharge<num_complex::Complex32>;
5640	fn mul(self, rhs: &InverseCharge<num_complex::Complex32>) -> Self::Output {
5641		InverseCharge{per_C: self * rhs.per_C.clone()}
5642	}
5643}
5644/// Multiplying a unit value by a scalar value returns a unit value
5645#[cfg(feature="num-complex")]
5646impl core::ops::Mul<&InverseCharge<num_complex::Complex32>> for &num_complex::Complex32 {
5647	type Output = InverseCharge<num_complex::Complex32>;
5648	fn mul(self, rhs: &InverseCharge<num_complex::Complex32>) -> Self::Output {
5649		InverseCharge{per_C: self.clone() * rhs.per_C.clone()}
5650	}
5651}
5652
5653/// Multiplying a unit value by a scalar value returns a unit value
5654#[cfg(feature="num-complex")]
5655impl core::ops::Mul<InverseCharge<num_complex::Complex64>> for num_complex::Complex64 {
5656	type Output = InverseCharge<num_complex::Complex64>;
5657	fn mul(self, rhs: InverseCharge<num_complex::Complex64>) -> Self::Output {
5658		InverseCharge{per_C: self * rhs.per_C}
5659	}
5660}
5661/// Multiplying a unit value by a scalar value returns a unit value
5662#[cfg(feature="num-complex")]
5663impl core::ops::Mul<InverseCharge<num_complex::Complex64>> for &num_complex::Complex64 {
5664	type Output = InverseCharge<num_complex::Complex64>;
5665	fn mul(self, rhs: InverseCharge<num_complex::Complex64>) -> Self::Output {
5666		InverseCharge{per_C: self.clone() * rhs.per_C}
5667	}
5668}
5669/// Multiplying a unit value by a scalar value returns a unit value
5670#[cfg(feature="num-complex")]
5671impl core::ops::Mul<&InverseCharge<num_complex::Complex64>> for num_complex::Complex64 {
5672	type Output = InverseCharge<num_complex::Complex64>;
5673	fn mul(self, rhs: &InverseCharge<num_complex::Complex64>) -> Self::Output {
5674		InverseCharge{per_C: self * rhs.per_C.clone()}
5675	}
5676}
5677/// Multiplying a unit value by a scalar value returns a unit value
5678#[cfg(feature="num-complex")]
5679impl core::ops::Mul<&InverseCharge<num_complex::Complex64>> for &num_complex::Complex64 {
5680	type Output = InverseCharge<num_complex::Complex64>;
5681	fn mul(self, rhs: &InverseCharge<num_complex::Complex64>) -> Self::Output {
5682		InverseCharge{per_C: self.clone() * rhs.per_C.clone()}
5683	}
5684}
5685
5686
5687
5688
5689// InverseCharge * Current -> Frequency
5690/// Multiplying a InverseCharge by a Current returns a value of type Frequency
5691impl<T> core::ops::Mul<Current<T>> for InverseCharge<T> where T: NumLike {
5692	type Output = Frequency<T>;
5693	fn mul(self, rhs: Current<T>) -> Self::Output {
5694		Frequency{Hz: self.per_C * rhs.A}
5695	}
5696}
5697/// Multiplying a InverseCharge by a Current returns a value of type Frequency
5698impl<T> core::ops::Mul<Current<T>> for &InverseCharge<T> where T: NumLike {
5699	type Output = Frequency<T>;
5700	fn mul(self, rhs: Current<T>) -> Self::Output {
5701		Frequency{Hz: self.per_C.clone() * rhs.A}
5702	}
5703}
5704/// Multiplying a InverseCharge by a Current returns a value of type Frequency
5705impl<T> core::ops::Mul<&Current<T>> for InverseCharge<T> where T: NumLike {
5706	type Output = Frequency<T>;
5707	fn mul(self, rhs: &Current<T>) -> Self::Output {
5708		Frequency{Hz: self.per_C * rhs.A.clone()}
5709	}
5710}
5711/// Multiplying a InverseCharge by a Current returns a value of type Frequency
5712impl<T> core::ops::Mul<&Current<T>> for &InverseCharge<T> where T: NumLike {
5713	type Output = Frequency<T>;
5714	fn mul(self, rhs: &Current<T>) -> Self::Output {
5715		Frequency{Hz: self.per_C.clone() * rhs.A.clone()}
5716	}
5717}
5718
5719// InverseCharge / InverseCurrent -> Frequency
5720/// Dividing a InverseCharge by a InverseCurrent returns a value of type Frequency
5721impl<T> core::ops::Div<InverseCurrent<T>> for InverseCharge<T> where T: NumLike {
5722	type Output = Frequency<T>;
5723	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
5724		Frequency{Hz: self.per_C / rhs.per_A}
5725	}
5726}
5727/// Dividing a InverseCharge by a InverseCurrent returns a value of type Frequency
5728impl<T> core::ops::Div<InverseCurrent<T>> for &InverseCharge<T> where T: NumLike {
5729	type Output = Frequency<T>;
5730	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
5731		Frequency{Hz: self.per_C.clone() / rhs.per_A}
5732	}
5733}
5734/// Dividing a InverseCharge by a InverseCurrent returns a value of type Frequency
5735impl<T> core::ops::Div<&InverseCurrent<T>> for InverseCharge<T> where T: NumLike {
5736	type Output = Frequency<T>;
5737	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
5738		Frequency{Hz: self.per_C / rhs.per_A.clone()}
5739	}
5740}
5741/// Dividing a InverseCharge by a InverseCurrent returns a value of type Frequency
5742impl<T> core::ops::Div<&InverseCurrent<T>> for &InverseCharge<T> where T: NumLike {
5743	type Output = Frequency<T>;
5744	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
5745		Frequency{Hz: self.per_C.clone() / rhs.per_A.clone()}
5746	}
5747}
5748
5749// InverseCharge * Time -> InverseCurrent
5750/// Multiplying a InverseCharge by a Time returns a value of type InverseCurrent
5751impl<T> core::ops::Mul<Time<T>> for InverseCharge<T> where T: NumLike {
5752	type Output = InverseCurrent<T>;
5753	fn mul(self, rhs: Time<T>) -> Self::Output {
5754		InverseCurrent{per_A: self.per_C * rhs.s}
5755	}
5756}
5757/// Multiplying a InverseCharge by a Time returns a value of type InverseCurrent
5758impl<T> core::ops::Mul<Time<T>> for &InverseCharge<T> where T: NumLike {
5759	type Output = InverseCurrent<T>;
5760	fn mul(self, rhs: Time<T>) -> Self::Output {
5761		InverseCurrent{per_A: self.per_C.clone() * rhs.s}
5762	}
5763}
5764/// Multiplying a InverseCharge by a Time returns a value of type InverseCurrent
5765impl<T> core::ops::Mul<&Time<T>> for InverseCharge<T> where T: NumLike {
5766	type Output = InverseCurrent<T>;
5767	fn mul(self, rhs: &Time<T>) -> Self::Output {
5768		InverseCurrent{per_A: self.per_C * rhs.s.clone()}
5769	}
5770}
5771/// Multiplying a InverseCharge by a Time returns a value of type InverseCurrent
5772impl<T> core::ops::Mul<&Time<T>> for &InverseCharge<T> where T: NumLike {
5773	type Output = InverseCurrent<T>;
5774	fn mul(self, rhs: &Time<T>) -> Self::Output {
5775		InverseCurrent{per_A: self.per_C.clone() * rhs.s.clone()}
5776	}
5777}
5778
5779// InverseCharge * Capacitance -> InverseVoltage
5780/// Multiplying a InverseCharge by a Capacitance returns a value of type InverseVoltage
5781impl<T> core::ops::Mul<Capacitance<T>> for InverseCharge<T> where T: NumLike {
5782	type Output = InverseVoltage<T>;
5783	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
5784		InverseVoltage{per_V: self.per_C * rhs.F}
5785	}
5786}
5787/// Multiplying a InverseCharge by a Capacitance returns a value of type InverseVoltage
5788impl<T> core::ops::Mul<Capacitance<T>> for &InverseCharge<T> where T: NumLike {
5789	type Output = InverseVoltage<T>;
5790	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
5791		InverseVoltage{per_V: self.per_C.clone() * rhs.F}
5792	}
5793}
5794/// Multiplying a InverseCharge by a Capacitance returns a value of type InverseVoltage
5795impl<T> core::ops::Mul<&Capacitance<T>> for InverseCharge<T> where T: NumLike {
5796	type Output = InverseVoltage<T>;
5797	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
5798		InverseVoltage{per_V: self.per_C * rhs.F.clone()}
5799	}
5800}
5801/// Multiplying a InverseCharge by a Capacitance returns a value of type InverseVoltage
5802impl<T> core::ops::Mul<&Capacitance<T>> for &InverseCharge<T> where T: NumLike {
5803	type Output = InverseVoltage<T>;
5804	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
5805		InverseVoltage{per_V: self.per_C.clone() * rhs.F.clone()}
5806	}
5807}
5808
5809// InverseCharge * Conductance -> InverseMagneticFlux
5810/// Multiplying a InverseCharge by a Conductance returns a value of type InverseMagneticFlux
5811impl<T> core::ops::Mul<Conductance<T>> for InverseCharge<T> where T: NumLike {
5812	type Output = InverseMagneticFlux<T>;
5813	fn mul(self, rhs: Conductance<T>) -> Self::Output {
5814		InverseMagneticFlux{per_Wb: self.per_C * rhs.S}
5815	}
5816}
5817/// Multiplying a InverseCharge by a Conductance returns a value of type InverseMagneticFlux
5818impl<T> core::ops::Mul<Conductance<T>> for &InverseCharge<T> where T: NumLike {
5819	type Output = InverseMagneticFlux<T>;
5820	fn mul(self, rhs: Conductance<T>) -> Self::Output {
5821		InverseMagneticFlux{per_Wb: self.per_C.clone() * rhs.S}
5822	}
5823}
5824/// Multiplying a InverseCharge by a Conductance returns a value of type InverseMagneticFlux
5825impl<T> core::ops::Mul<&Conductance<T>> for InverseCharge<T> where T: NumLike {
5826	type Output = InverseMagneticFlux<T>;
5827	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
5828		InverseMagneticFlux{per_Wb: self.per_C * rhs.S.clone()}
5829	}
5830}
5831/// Multiplying a InverseCharge by a Conductance returns a value of type InverseMagneticFlux
5832impl<T> core::ops::Mul<&Conductance<T>> for &InverseCharge<T> where T: NumLike {
5833	type Output = InverseMagneticFlux<T>;
5834	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
5835		InverseMagneticFlux{per_Wb: self.per_C.clone() * rhs.S.clone()}
5836	}
5837}
5838
5839// InverseCharge / Elastance -> InverseVoltage
5840/// Dividing a InverseCharge by a Elastance returns a value of type InverseVoltage
5841impl<T> core::ops::Div<Elastance<T>> for InverseCharge<T> where T: NumLike {
5842	type Output = InverseVoltage<T>;
5843	fn div(self, rhs: Elastance<T>) -> Self::Output {
5844		InverseVoltage{per_V: self.per_C / rhs.per_F}
5845	}
5846}
5847/// Dividing a InverseCharge by a Elastance returns a value of type InverseVoltage
5848impl<T> core::ops::Div<Elastance<T>> for &InverseCharge<T> where T: NumLike {
5849	type Output = InverseVoltage<T>;
5850	fn div(self, rhs: Elastance<T>) -> Self::Output {
5851		InverseVoltage{per_V: self.per_C.clone() / rhs.per_F}
5852	}
5853}
5854/// Dividing a InverseCharge by a Elastance returns a value of type InverseVoltage
5855impl<T> core::ops::Div<&Elastance<T>> for InverseCharge<T> where T: NumLike {
5856	type Output = InverseVoltage<T>;
5857	fn div(self, rhs: &Elastance<T>) -> Self::Output {
5858		InverseVoltage{per_V: self.per_C / rhs.per_F.clone()}
5859	}
5860}
5861/// Dividing a InverseCharge by a Elastance returns a value of type InverseVoltage
5862impl<T> core::ops::Div<&Elastance<T>> for &InverseCharge<T> where T: NumLike {
5863	type Output = InverseVoltage<T>;
5864	fn div(self, rhs: &Elastance<T>) -> Self::Output {
5865		InverseVoltage{per_V: self.per_C.clone() / rhs.per_F.clone()}
5866	}
5867}
5868
5869// InverseCharge / InverseMagneticFlux -> Resistance
5870/// Dividing a InverseCharge by a InverseMagneticFlux returns a value of type Resistance
5871impl<T> core::ops::Div<InverseMagneticFlux<T>> for InverseCharge<T> where T: NumLike {
5872	type Output = Resistance<T>;
5873	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
5874		Resistance{Ohm: self.per_C / rhs.per_Wb}
5875	}
5876}
5877/// Dividing a InverseCharge by a InverseMagneticFlux returns a value of type Resistance
5878impl<T> core::ops::Div<InverseMagneticFlux<T>> for &InverseCharge<T> where T: NumLike {
5879	type Output = Resistance<T>;
5880	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
5881		Resistance{Ohm: self.per_C.clone() / rhs.per_Wb}
5882	}
5883}
5884/// Dividing a InverseCharge by a InverseMagneticFlux returns a value of type Resistance
5885impl<T> core::ops::Div<&InverseMagneticFlux<T>> for InverseCharge<T> where T: NumLike {
5886	type Output = Resistance<T>;
5887	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
5888		Resistance{Ohm: self.per_C / rhs.per_Wb.clone()}
5889	}
5890}
5891/// Dividing a InverseCharge by a InverseMagneticFlux returns a value of type Resistance
5892impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &InverseCharge<T> where T: NumLike {
5893	type Output = Resistance<T>;
5894	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
5895		Resistance{Ohm: self.per_C.clone() / rhs.per_Wb.clone()}
5896	}
5897}
5898
5899// InverseCharge * InverseVoltage -> InverseEnergy
5900/// Multiplying a InverseCharge by a InverseVoltage returns a value of type InverseEnergy
5901impl<T> core::ops::Mul<InverseVoltage<T>> for InverseCharge<T> where T: NumLike {
5902	type Output = InverseEnergy<T>;
5903	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
5904		InverseEnergy{per_J: self.per_C * rhs.per_V}
5905	}
5906}
5907/// Multiplying a InverseCharge by a InverseVoltage returns a value of type InverseEnergy
5908impl<T> core::ops::Mul<InverseVoltage<T>> for &InverseCharge<T> where T: NumLike {
5909	type Output = InverseEnergy<T>;
5910	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
5911		InverseEnergy{per_J: self.per_C.clone() * rhs.per_V}
5912	}
5913}
5914/// Multiplying a InverseCharge by a InverseVoltage returns a value of type InverseEnergy
5915impl<T> core::ops::Mul<&InverseVoltage<T>> for InverseCharge<T> where T: NumLike {
5916	type Output = InverseEnergy<T>;
5917	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
5918		InverseEnergy{per_J: self.per_C * rhs.per_V.clone()}
5919	}
5920}
5921/// Multiplying a InverseCharge by a InverseVoltage returns a value of type InverseEnergy
5922impl<T> core::ops::Mul<&InverseVoltage<T>> for &InverseCharge<T> where T: NumLike {
5923	type Output = InverseEnergy<T>;
5924	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
5925		InverseEnergy{per_J: self.per_C.clone() * rhs.per_V.clone()}
5926	}
5927}
5928
5929// InverseCharge / InverseVoltage -> Elastance
5930/// Dividing a InverseCharge by a InverseVoltage returns a value of type Elastance
5931impl<T> core::ops::Div<InverseVoltage<T>> for InverseCharge<T> where T: NumLike {
5932	type Output = Elastance<T>;
5933	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
5934		Elastance{per_F: self.per_C / rhs.per_V}
5935	}
5936}
5937/// Dividing a InverseCharge by a InverseVoltage returns a value of type Elastance
5938impl<T> core::ops::Div<InverseVoltage<T>> for &InverseCharge<T> where T: NumLike {
5939	type Output = Elastance<T>;
5940	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
5941		Elastance{per_F: self.per_C.clone() / rhs.per_V}
5942	}
5943}
5944/// Dividing a InverseCharge by a InverseVoltage returns a value of type Elastance
5945impl<T> core::ops::Div<&InverseVoltage<T>> for InverseCharge<T> where T: NumLike {
5946	type Output = Elastance<T>;
5947	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
5948		Elastance{per_F: self.per_C / rhs.per_V.clone()}
5949	}
5950}
5951/// Dividing a InverseCharge by a InverseVoltage returns a value of type Elastance
5952impl<T> core::ops::Div<&InverseVoltage<T>> for &InverseCharge<T> where T: NumLike {
5953	type Output = Elastance<T>;
5954	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
5955		Elastance{per_F: self.per_C.clone() / rhs.per_V.clone()}
5956	}
5957}
5958
5959// InverseCharge * MagneticFlux -> Resistance
5960/// Multiplying a InverseCharge by a MagneticFlux returns a value of type Resistance
5961impl<T> core::ops::Mul<MagneticFlux<T>> for InverseCharge<T> where T: NumLike {
5962	type Output = Resistance<T>;
5963	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
5964		Resistance{Ohm: self.per_C * rhs.Wb}
5965	}
5966}
5967/// Multiplying a InverseCharge by a MagneticFlux returns a value of type Resistance
5968impl<T> core::ops::Mul<MagneticFlux<T>> for &InverseCharge<T> where T: NumLike {
5969	type Output = Resistance<T>;
5970	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
5971		Resistance{Ohm: self.per_C.clone() * rhs.Wb}
5972	}
5973}
5974/// Multiplying a InverseCharge by a MagneticFlux returns a value of type Resistance
5975impl<T> core::ops::Mul<&MagneticFlux<T>> for InverseCharge<T> where T: NumLike {
5976	type Output = Resistance<T>;
5977	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
5978		Resistance{Ohm: self.per_C * rhs.Wb.clone()}
5979	}
5980}
5981/// Multiplying a InverseCharge by a MagneticFlux returns a value of type Resistance
5982impl<T> core::ops::Mul<&MagneticFlux<T>> for &InverseCharge<T> where T: NumLike {
5983	type Output = Resistance<T>;
5984	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
5985		Resistance{Ohm: self.per_C.clone() * rhs.Wb.clone()}
5986	}
5987}
5988
5989// InverseCharge / Resistance -> InverseMagneticFlux
5990/// Dividing a InverseCharge by a Resistance returns a value of type InverseMagneticFlux
5991impl<T> core::ops::Div<Resistance<T>> for InverseCharge<T> where T: NumLike {
5992	type Output = InverseMagneticFlux<T>;
5993	fn div(self, rhs: Resistance<T>) -> Self::Output {
5994		InverseMagneticFlux{per_Wb: self.per_C / rhs.Ohm}
5995	}
5996}
5997/// Dividing a InverseCharge by a Resistance returns a value of type InverseMagneticFlux
5998impl<T> core::ops::Div<Resistance<T>> for &InverseCharge<T> where T: NumLike {
5999	type Output = InverseMagneticFlux<T>;
6000	fn div(self, rhs: Resistance<T>) -> Self::Output {
6001		InverseMagneticFlux{per_Wb: self.per_C.clone() / rhs.Ohm}
6002	}
6003}
6004/// Dividing a InverseCharge by a Resistance returns a value of type InverseMagneticFlux
6005impl<T> core::ops::Div<&Resistance<T>> for InverseCharge<T> where T: NumLike {
6006	type Output = InverseMagneticFlux<T>;
6007	fn div(self, rhs: &Resistance<T>) -> Self::Output {
6008		InverseMagneticFlux{per_Wb: self.per_C / rhs.Ohm.clone()}
6009	}
6010}
6011/// Dividing a InverseCharge by a Resistance returns a value of type InverseMagneticFlux
6012impl<T> core::ops::Div<&Resistance<T>> for &InverseCharge<T> where T: NumLike {
6013	type Output = InverseMagneticFlux<T>;
6014	fn div(self, rhs: &Resistance<T>) -> Self::Output {
6015		InverseMagneticFlux{per_Wb: self.per_C.clone() / rhs.Ohm.clone()}
6016	}
6017}
6018
6019// InverseCharge * Voltage -> Elastance
6020/// Multiplying a InverseCharge by a Voltage returns a value of type Elastance
6021impl<T> core::ops::Mul<Voltage<T>> for InverseCharge<T> where T: NumLike {
6022	type Output = Elastance<T>;
6023	fn mul(self, rhs: Voltage<T>) -> Self::Output {
6024		Elastance{per_F: self.per_C * rhs.V}
6025	}
6026}
6027/// Multiplying a InverseCharge by a Voltage returns a value of type Elastance
6028impl<T> core::ops::Mul<Voltage<T>> for &InverseCharge<T> where T: NumLike {
6029	type Output = Elastance<T>;
6030	fn mul(self, rhs: Voltage<T>) -> Self::Output {
6031		Elastance{per_F: self.per_C.clone() * rhs.V}
6032	}
6033}
6034/// Multiplying a InverseCharge by a Voltage returns a value of type Elastance
6035impl<T> core::ops::Mul<&Voltage<T>> for InverseCharge<T> where T: NumLike {
6036	type Output = Elastance<T>;
6037	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
6038		Elastance{per_F: self.per_C * rhs.V.clone()}
6039	}
6040}
6041/// Multiplying a InverseCharge by a Voltage returns a value of type Elastance
6042impl<T> core::ops::Mul<&Voltage<T>> for &InverseCharge<T> where T: NumLike {
6043	type Output = Elastance<T>;
6044	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
6045		Elastance{per_F: self.per_C.clone() * rhs.V.clone()}
6046	}
6047}
6048
6049// InverseCharge / Voltage -> InverseEnergy
6050/// Dividing a InverseCharge by a Voltage returns a value of type InverseEnergy
6051impl<T> core::ops::Div<Voltage<T>> for InverseCharge<T> where T: NumLike {
6052	type Output = InverseEnergy<T>;
6053	fn div(self, rhs: Voltage<T>) -> Self::Output {
6054		InverseEnergy{per_J: self.per_C / rhs.V}
6055	}
6056}
6057/// Dividing a InverseCharge by a Voltage returns a value of type InverseEnergy
6058impl<T> core::ops::Div<Voltage<T>> for &InverseCharge<T> where T: NumLike {
6059	type Output = InverseEnergy<T>;
6060	fn div(self, rhs: Voltage<T>) -> Self::Output {
6061		InverseEnergy{per_J: self.per_C.clone() / rhs.V}
6062	}
6063}
6064/// Dividing a InverseCharge by a Voltage returns a value of type InverseEnergy
6065impl<T> core::ops::Div<&Voltage<T>> for InverseCharge<T> where T: NumLike {
6066	type Output = InverseEnergy<T>;
6067	fn div(self, rhs: &Voltage<T>) -> Self::Output {
6068		InverseEnergy{per_J: self.per_C / rhs.V.clone()}
6069	}
6070}
6071/// Dividing a InverseCharge by a Voltage returns a value of type InverseEnergy
6072impl<T> core::ops::Div<&Voltage<T>> for &InverseCharge<T> where T: NumLike {
6073	type Output = InverseEnergy<T>;
6074	fn div(self, rhs: &Voltage<T>) -> Self::Output {
6075		InverseEnergy{per_J: self.per_C.clone() / rhs.V.clone()}
6076	}
6077}
6078
6079// InverseCharge * Energy -> Voltage
6080/// Multiplying a InverseCharge by a Energy returns a value of type Voltage
6081impl<T> core::ops::Mul<Energy<T>> for InverseCharge<T> where T: NumLike {
6082	type Output = Voltage<T>;
6083	fn mul(self, rhs: Energy<T>) -> Self::Output {
6084		Voltage{V: self.per_C * rhs.J}
6085	}
6086}
6087/// Multiplying a InverseCharge by a Energy returns a value of type Voltage
6088impl<T> core::ops::Mul<Energy<T>> for &InverseCharge<T> where T: NumLike {
6089	type Output = Voltage<T>;
6090	fn mul(self, rhs: Energy<T>) -> Self::Output {
6091		Voltage{V: self.per_C.clone() * rhs.J}
6092	}
6093}
6094/// Multiplying a InverseCharge by a Energy returns a value of type Voltage
6095impl<T> core::ops::Mul<&Energy<T>> for InverseCharge<T> where T: NumLike {
6096	type Output = Voltage<T>;
6097	fn mul(self, rhs: &Energy<T>) -> Self::Output {
6098		Voltage{V: self.per_C * rhs.J.clone()}
6099	}
6100}
6101/// Multiplying a InverseCharge by a Energy returns a value of type Voltage
6102impl<T> core::ops::Mul<&Energy<T>> for &InverseCharge<T> where T: NumLike {
6103	type Output = Voltage<T>;
6104	fn mul(self, rhs: &Energy<T>) -> Self::Output {
6105		Voltage{V: self.per_C.clone() * rhs.J.clone()}
6106	}
6107}
6108
6109// InverseCharge * Torque -> Voltage
6110/// Multiplying a InverseCharge by a Torque returns a value of type Voltage
6111impl<T> core::ops::Mul<Torque<T>> for InverseCharge<T> where T: NumLike {
6112	type Output = Voltage<T>;
6113	fn mul(self, rhs: Torque<T>) -> Self::Output {
6114		Voltage{V: self.per_C * rhs.Nm}
6115	}
6116}
6117/// Multiplying a InverseCharge by a Torque returns a value of type Voltage
6118impl<T> core::ops::Mul<Torque<T>> for &InverseCharge<T> where T: NumLike {
6119	type Output = Voltage<T>;
6120	fn mul(self, rhs: Torque<T>) -> Self::Output {
6121		Voltage{V: self.per_C.clone() * rhs.Nm}
6122	}
6123}
6124/// Multiplying a InverseCharge by a Torque returns a value of type Voltage
6125impl<T> core::ops::Mul<&Torque<T>> for InverseCharge<T> where T: NumLike {
6126	type Output = Voltage<T>;
6127	fn mul(self, rhs: &Torque<T>) -> Self::Output {
6128		Voltage{V: self.per_C * rhs.Nm.clone()}
6129	}
6130}
6131/// Multiplying a InverseCharge by a Torque returns a value of type Voltage
6132impl<T> core::ops::Mul<&Torque<T>> for &InverseCharge<T> where T: NumLike {
6133	type Output = Voltage<T>;
6134	fn mul(self, rhs: &Torque<T>) -> Self::Output {
6135		Voltage{V: self.per_C.clone() * rhs.Nm.clone()}
6136	}
6137}
6138
6139// InverseCharge / Frequency -> InverseCurrent
6140/// Dividing a InverseCharge by a Frequency returns a value of type InverseCurrent
6141impl<T> core::ops::Div<Frequency<T>> for InverseCharge<T> where T: NumLike {
6142	type Output = InverseCurrent<T>;
6143	fn div(self, rhs: Frequency<T>) -> Self::Output {
6144		InverseCurrent{per_A: self.per_C / rhs.Hz}
6145	}
6146}
6147/// Dividing a InverseCharge by a Frequency returns a value of type InverseCurrent
6148impl<T> core::ops::Div<Frequency<T>> for &InverseCharge<T> where T: NumLike {
6149	type Output = InverseCurrent<T>;
6150	fn div(self, rhs: Frequency<T>) -> Self::Output {
6151		InverseCurrent{per_A: self.per_C.clone() / rhs.Hz}
6152	}
6153}
6154/// Dividing a InverseCharge by a Frequency returns a value of type InverseCurrent
6155impl<T> core::ops::Div<&Frequency<T>> for InverseCharge<T> where T: NumLike {
6156	type Output = InverseCurrent<T>;
6157	fn div(self, rhs: &Frequency<T>) -> Self::Output {
6158		InverseCurrent{per_A: self.per_C / rhs.Hz.clone()}
6159	}
6160}
6161/// Dividing a InverseCharge by a Frequency returns a value of type InverseCurrent
6162impl<T> core::ops::Div<&Frequency<T>> for &InverseCharge<T> where T: NumLike {
6163	type Output = InverseCurrent<T>;
6164	fn div(self, rhs: &Frequency<T>) -> Self::Output {
6165		InverseCurrent{per_A: self.per_C.clone() / rhs.Hz.clone()}
6166	}
6167}
6168
6169// InverseCharge / InverseEnergy -> Voltage
6170/// Dividing a InverseCharge by a InverseEnergy returns a value of type Voltage
6171impl<T> core::ops::Div<InverseEnergy<T>> for InverseCharge<T> where T: NumLike {
6172	type Output = Voltage<T>;
6173	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
6174		Voltage{V: self.per_C / rhs.per_J}
6175	}
6176}
6177/// Dividing a InverseCharge by a InverseEnergy returns a value of type Voltage
6178impl<T> core::ops::Div<InverseEnergy<T>> for &InverseCharge<T> where T: NumLike {
6179	type Output = Voltage<T>;
6180	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
6181		Voltage{V: self.per_C.clone() / rhs.per_J}
6182	}
6183}
6184/// Dividing a InverseCharge by a InverseEnergy returns a value of type Voltage
6185impl<T> core::ops::Div<&InverseEnergy<T>> for InverseCharge<T> where T: NumLike {
6186	type Output = Voltage<T>;
6187	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
6188		Voltage{V: self.per_C / rhs.per_J.clone()}
6189	}
6190}
6191/// Dividing a InverseCharge by a InverseEnergy returns a value of type Voltage
6192impl<T> core::ops::Div<&InverseEnergy<T>> for &InverseCharge<T> where T: NumLike {
6193	type Output = Voltage<T>;
6194	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
6195		Voltage{V: self.per_C.clone() / rhs.per_J.clone()}
6196	}
6197}
6198
6199// InverseCharge / InverseTorque -> Voltage
6200/// Dividing a InverseCharge by a InverseTorque returns a value of type Voltage
6201impl<T> core::ops::Div<InverseTorque<T>> for InverseCharge<T> where T: NumLike {
6202	type Output = Voltage<T>;
6203	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
6204		Voltage{V: self.per_C / rhs.per_Nm}
6205	}
6206}
6207/// Dividing a InverseCharge by a InverseTorque returns a value of type Voltage
6208impl<T> core::ops::Div<InverseTorque<T>> for &InverseCharge<T> where T: NumLike {
6209	type Output = Voltage<T>;
6210	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
6211		Voltage{V: self.per_C.clone() / rhs.per_Nm}
6212	}
6213}
6214/// Dividing a InverseCharge by a InverseTorque returns a value of type Voltage
6215impl<T> core::ops::Div<&InverseTorque<T>> for InverseCharge<T> where T: NumLike {
6216	type Output = Voltage<T>;
6217	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
6218		Voltage{V: self.per_C / rhs.per_Nm.clone()}
6219	}
6220}
6221/// Dividing a InverseCharge by a InverseTorque returns a value of type Voltage
6222impl<T> core::ops::Div<&InverseTorque<T>> for &InverseCharge<T> where T: NumLike {
6223	type Output = Voltage<T>;
6224	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
6225		Voltage{V: self.per_C.clone() / rhs.per_Nm.clone()}
6226	}
6227}
6228
6229// 1/InverseCharge -> Charge
6230/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6231impl<T> core::ops::Div<InverseCharge<T>> for f64 where T: NumLike+From<f64> {
6232	type Output = Charge<T>;
6233	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6234		Charge{C: T::from(self) / rhs.per_C}
6235	}
6236}
6237/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6238impl<T> core::ops::Div<InverseCharge<T>> for &f64 where T: NumLike+From<f64> {
6239	type Output = Charge<T>;
6240	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6241		Charge{C: T::from(self.clone()) / rhs.per_C}
6242	}
6243}
6244/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6245impl<T> core::ops::Div<&InverseCharge<T>> for f64 where T: NumLike+From<f64> {
6246	type Output = Charge<T>;
6247	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6248		Charge{C: T::from(self) / rhs.per_C.clone()}
6249	}
6250}
6251/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6252impl<T> core::ops::Div<&InverseCharge<T>> for &f64 where T: NumLike+From<f64> {
6253	type Output = Charge<T>;
6254	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6255		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6256	}
6257}
6258
6259// 1/InverseCharge -> Charge
6260/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6261impl<T> core::ops::Div<InverseCharge<T>> for f32 where T: NumLike+From<f32> {
6262	type Output = Charge<T>;
6263	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6264		Charge{C: T::from(self) / rhs.per_C}
6265	}
6266}
6267/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6268impl<T> core::ops::Div<InverseCharge<T>> for &f32 where T: NumLike+From<f32> {
6269	type Output = Charge<T>;
6270	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6271		Charge{C: T::from(self.clone()) / rhs.per_C}
6272	}
6273}
6274/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6275impl<T> core::ops::Div<&InverseCharge<T>> for f32 where T: NumLike+From<f32> {
6276	type Output = Charge<T>;
6277	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6278		Charge{C: T::from(self) / rhs.per_C.clone()}
6279	}
6280}
6281/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6282impl<T> core::ops::Div<&InverseCharge<T>> for &f32 where T: NumLike+From<f32> {
6283	type Output = Charge<T>;
6284	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6285		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6286	}
6287}
6288
6289// 1/InverseCharge -> Charge
6290/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6291impl<T> core::ops::Div<InverseCharge<T>> for i64 where T: NumLike+From<i64> {
6292	type Output = Charge<T>;
6293	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6294		Charge{C: T::from(self) / rhs.per_C}
6295	}
6296}
6297/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6298impl<T> core::ops::Div<InverseCharge<T>> for &i64 where T: NumLike+From<i64> {
6299	type Output = Charge<T>;
6300	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6301		Charge{C: T::from(self.clone()) / rhs.per_C}
6302	}
6303}
6304/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6305impl<T> core::ops::Div<&InverseCharge<T>> for i64 where T: NumLike+From<i64> {
6306	type Output = Charge<T>;
6307	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6308		Charge{C: T::from(self) / rhs.per_C.clone()}
6309	}
6310}
6311/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6312impl<T> core::ops::Div<&InverseCharge<T>> for &i64 where T: NumLike+From<i64> {
6313	type Output = Charge<T>;
6314	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6315		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6316	}
6317}
6318
6319// 1/InverseCharge -> Charge
6320/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6321impl<T> core::ops::Div<InverseCharge<T>> for i32 where T: NumLike+From<i32> {
6322	type Output = Charge<T>;
6323	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6324		Charge{C: T::from(self) / rhs.per_C}
6325	}
6326}
6327/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6328impl<T> core::ops::Div<InverseCharge<T>> for &i32 where T: NumLike+From<i32> {
6329	type Output = Charge<T>;
6330	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6331		Charge{C: T::from(self.clone()) / rhs.per_C}
6332	}
6333}
6334/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6335impl<T> core::ops::Div<&InverseCharge<T>> for i32 where T: NumLike+From<i32> {
6336	type Output = Charge<T>;
6337	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6338		Charge{C: T::from(self) / rhs.per_C.clone()}
6339	}
6340}
6341/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6342impl<T> core::ops::Div<&InverseCharge<T>> for &i32 where T: NumLike+From<i32> {
6343	type Output = Charge<T>;
6344	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6345		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6346	}
6347}
6348
6349// 1/InverseCharge -> Charge
6350/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6351#[cfg(feature="num-bigfloat")]
6352impl<T> core::ops::Div<InverseCharge<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
6353	type Output = Charge<T>;
6354	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6355		Charge{C: T::from(self) / rhs.per_C}
6356	}
6357}
6358/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6359#[cfg(feature="num-bigfloat")]
6360impl<T> core::ops::Div<InverseCharge<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
6361	type Output = Charge<T>;
6362	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6363		Charge{C: T::from(self.clone()) / rhs.per_C}
6364	}
6365}
6366/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6367#[cfg(feature="num-bigfloat")]
6368impl<T> core::ops::Div<&InverseCharge<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
6369	type Output = Charge<T>;
6370	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6371		Charge{C: T::from(self) / rhs.per_C.clone()}
6372	}
6373}
6374/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6375#[cfg(feature="num-bigfloat")]
6376impl<T> core::ops::Div<&InverseCharge<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
6377	type Output = Charge<T>;
6378	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6379		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6380	}
6381}
6382
6383// 1/InverseCharge -> Charge
6384/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6385#[cfg(feature="num-complex")]
6386impl<T> core::ops::Div<InverseCharge<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
6387	type Output = Charge<T>;
6388	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6389		Charge{C: T::from(self) / rhs.per_C}
6390	}
6391}
6392/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6393#[cfg(feature="num-complex")]
6394impl<T> core::ops::Div<InverseCharge<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
6395	type Output = Charge<T>;
6396	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6397		Charge{C: T::from(self.clone()) / rhs.per_C}
6398	}
6399}
6400/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6401#[cfg(feature="num-complex")]
6402impl<T> core::ops::Div<&InverseCharge<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
6403	type Output = Charge<T>;
6404	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6405		Charge{C: T::from(self) / rhs.per_C.clone()}
6406	}
6407}
6408/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6409#[cfg(feature="num-complex")]
6410impl<T> core::ops::Div<&InverseCharge<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
6411	type Output = Charge<T>;
6412	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6413		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6414	}
6415}
6416
6417// 1/InverseCharge -> Charge
6418/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6419#[cfg(feature="num-complex")]
6420impl<T> core::ops::Div<InverseCharge<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
6421	type Output = Charge<T>;
6422	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6423		Charge{C: T::from(self) / rhs.per_C}
6424	}
6425}
6426/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6427#[cfg(feature="num-complex")]
6428impl<T> core::ops::Div<InverseCharge<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
6429	type Output = Charge<T>;
6430	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
6431		Charge{C: T::from(self.clone()) / rhs.per_C}
6432	}
6433}
6434/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6435#[cfg(feature="num-complex")]
6436impl<T> core::ops::Div<&InverseCharge<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
6437	type Output = Charge<T>;
6438	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6439		Charge{C: T::from(self) / rhs.per_C.clone()}
6440	}
6441}
6442/// Dividing a scalar value by a InverseCharge unit value returns a value of type Charge
6443#[cfg(feature="num-complex")]
6444impl<T> core::ops::Div<&InverseCharge<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
6445	type Output = Charge<T>;
6446	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
6447		Charge{C: T::from(self.clone()) / rhs.per_C.clone()}
6448	}
6449}
6450
6451/// The inverse of inductance unit type, defined as inverse henries in SI units
6452#[derive(UnitStruct, Debug, Clone)]
6453#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
6454pub struct InverseInductance<T: NumLike>{
6455	/// The value of this Inverse inductance in inverse henries
6456	pub per_H: T
6457}
6458
6459impl<T> InverseInductance<T> where T: NumLike {
6460
6461	/// Returns the standard unit name of inverse inductance: "inverse henries"
6462	pub fn unit_name() -> &'static str { "inverse henries" }
6463	
6464	/// Returns the abbreviated name or symbol of inverse inductance: "1/H" for inverse henries
6465	pub fn unit_symbol() -> &'static str { "1/H" }
6466	
6467	/// Returns a new inverse inductance value from the given number of inverse henries
6468	///
6469	/// # Arguments
6470	/// * `per_H` - Any number-like type, representing a quantity of inverse henries
6471	pub fn from_per_H(per_H: T) -> Self { InverseInductance{per_H: per_H} }
6472	
6473	/// Returns a copy of this inverse inductance value in inverse henries
6474	pub fn to_per_H(&self) -> T { self.per_H.clone() }
6475
6476	/// Returns a new inverse inductance value from the given number of inverse henries
6477	///
6478	/// # Arguments
6479	/// * `per_henry` - Any number-like type, representing a quantity of inverse henries
6480	pub fn from_per_henry(per_henry: T) -> Self { InverseInductance{per_H: per_henry} }
6481	
6482	/// Returns a copy of this inverse inductance value in inverse henries
6483	pub fn to_per_henry(&self) -> T { self.per_H.clone() }
6484
6485}
6486
6487impl<T> fmt::Display for InverseInductance<T> where T: NumLike {
6488	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6489		write!(f, "{} {}", &self.per_H, Self::unit_symbol())
6490	}
6491}
6492
6493impl<T> InverseInductance<T> where T: NumLike+From<f64> {
6494	
6495	/// Returns a copy of this inverse inductance value in inverse millihenries
6496	/// 
6497	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6498	pub fn to_per_mH(&self) -> T {
6499		return self.per_H.clone() * T::from(0.001_f64);
6500	}
6501
6502	/// Returns a new inverse inductance value from the given number of inverse millihenries
6503	/// 
6504	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6505	///
6506	/// # Arguments
6507	/// * `per_mH` - Any number-like type, representing a quantity of inverse millihenries
6508	pub fn from_per_mH(per_mH: T) -> Self {
6509		InverseInductance{per_H: per_mH * T::from(1000.0_f64)}
6510	}
6511
6512	/// Returns a copy of this inverse inductance value in inverse microhenries
6513	/// 
6514	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6515	pub fn to_per_uH(&self) -> T {
6516		return self.per_H.clone() * T::from(1e-06_f64);
6517	}
6518
6519	/// Returns a new inverse inductance value from the given number of inverse microhenries
6520	/// 
6521	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6522	///
6523	/// # Arguments
6524	/// * `per_uH` - Any number-like type, representing a quantity of inverse microhenries
6525	pub fn from_per_uH(per_uH: T) -> Self {
6526		InverseInductance{per_H: per_uH * T::from(1000000.0_f64)}
6527	}
6528
6529	/// Returns a copy of this inverse inductance value in inverse nanohenries
6530	/// 
6531	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6532	pub fn to_per_nH(&self) -> T {
6533		return self.per_H.clone() * T::from(1e-09_f64);
6534	}
6535
6536	/// Returns a new inverse inductance value from the given number of inverse nanohenries
6537	/// 
6538	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6539	///
6540	/// # Arguments
6541	/// * `per_nH` - Any number-like type, representing a quantity of inverse nanohenries
6542	pub fn from_per_nH(per_nH: T) -> Self {
6543		InverseInductance{per_H: per_nH * T::from(1000000000.0_f64)}
6544	}
6545
6546	/// Returns a copy of this inverse inductance value in inverse kilohenries
6547	/// 
6548	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6549	pub fn to_per_kH(&self) -> T {
6550		return self.per_H.clone() * T::from(1000.0_f64);
6551	}
6552
6553	/// Returns a new inverse inductance value from the given number of inverse kilohenries
6554	/// 
6555	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6556	///
6557	/// # Arguments
6558	/// * `per_kH` - Any number-like type, representing a quantity of inverse kilohenries
6559	pub fn from_per_kH(per_kH: T) -> Self {
6560		InverseInductance{per_H: per_kH * T::from(0.001_f64)}
6561	}
6562
6563	/// Returns a copy of this inverse inductance value in inverse megahenries
6564	/// 
6565	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6566	pub fn to_per_MH(&self) -> T {
6567		return self.per_H.clone() * T::from(1000000.0_f64);
6568	}
6569
6570	/// Returns a new inverse inductance value from the given number of inverse megahenries
6571	/// 
6572	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6573	///
6574	/// # Arguments
6575	/// * `per_MH` - Any number-like type, representing a quantity of inverse megahenries
6576	pub fn from_per_MH(per_MH: T) -> Self {
6577		InverseInductance{per_H: per_MH * T::from(1e-06_f64)}
6578	}
6579
6580	/// Returns a copy of this inverse inductance value in inverse gigahenries
6581	/// 
6582	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6583	pub fn to_per_GH(&self) -> T {
6584		return self.per_H.clone() * T::from(1000000000.0_f64);
6585	}
6586
6587	/// Returns a new inverse inductance value from the given number of inverse gigahenries
6588	/// 
6589	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
6590	///
6591	/// # Arguments
6592	/// * `per_GH` - Any number-like type, representing a quantity of inverse gigahenries
6593	pub fn from_per_GH(per_GH: T) -> Self {
6594		InverseInductance{per_H: per_GH * T::from(1e-09_f64)}
6595	}
6596
6597}
6598
6599
6600/// Multiplying a unit value by a scalar value returns a unit value
6601#[cfg(feature="num-bigfloat")]
6602impl core::ops::Mul<InverseInductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
6603	type Output = InverseInductance<num_bigfloat::BigFloat>;
6604	fn mul(self, rhs: InverseInductance<num_bigfloat::BigFloat>) -> Self::Output {
6605		InverseInductance{per_H: self * rhs.per_H}
6606	}
6607}
6608/// Multiplying a unit value by a scalar value returns a unit value
6609#[cfg(feature="num-bigfloat")]
6610impl core::ops::Mul<InverseInductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
6611	type Output = InverseInductance<num_bigfloat::BigFloat>;
6612	fn mul(self, rhs: InverseInductance<num_bigfloat::BigFloat>) -> Self::Output {
6613		InverseInductance{per_H: self.clone() * rhs.per_H}
6614	}
6615}
6616/// Multiplying a unit value by a scalar value returns a unit value
6617#[cfg(feature="num-bigfloat")]
6618impl core::ops::Mul<&InverseInductance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
6619	type Output = InverseInductance<num_bigfloat::BigFloat>;
6620	fn mul(self, rhs: &InverseInductance<num_bigfloat::BigFloat>) -> Self::Output {
6621		InverseInductance{per_H: self * rhs.per_H.clone()}
6622	}
6623}
6624/// Multiplying a unit value by a scalar value returns a unit value
6625#[cfg(feature="num-bigfloat")]
6626impl core::ops::Mul<&InverseInductance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
6627	type Output = InverseInductance<num_bigfloat::BigFloat>;
6628	fn mul(self, rhs: &InverseInductance<num_bigfloat::BigFloat>) -> Self::Output {
6629		InverseInductance{per_H: self.clone() * rhs.per_H.clone()}
6630	}
6631}
6632
6633/// Multiplying a unit value by a scalar value returns a unit value
6634#[cfg(feature="num-complex")]
6635impl core::ops::Mul<InverseInductance<num_complex::Complex32>> for num_complex::Complex32 {
6636	type Output = InverseInductance<num_complex::Complex32>;
6637	fn mul(self, rhs: InverseInductance<num_complex::Complex32>) -> Self::Output {
6638		InverseInductance{per_H: self * rhs.per_H}
6639	}
6640}
6641/// Multiplying a unit value by a scalar value returns a unit value
6642#[cfg(feature="num-complex")]
6643impl core::ops::Mul<InverseInductance<num_complex::Complex32>> for &num_complex::Complex32 {
6644	type Output = InverseInductance<num_complex::Complex32>;
6645	fn mul(self, rhs: InverseInductance<num_complex::Complex32>) -> Self::Output {
6646		InverseInductance{per_H: self.clone() * rhs.per_H}
6647	}
6648}
6649/// Multiplying a unit value by a scalar value returns a unit value
6650#[cfg(feature="num-complex")]
6651impl core::ops::Mul<&InverseInductance<num_complex::Complex32>> for num_complex::Complex32 {
6652	type Output = InverseInductance<num_complex::Complex32>;
6653	fn mul(self, rhs: &InverseInductance<num_complex::Complex32>) -> Self::Output {
6654		InverseInductance{per_H: self * rhs.per_H.clone()}
6655	}
6656}
6657/// Multiplying a unit value by a scalar value returns a unit value
6658#[cfg(feature="num-complex")]
6659impl core::ops::Mul<&InverseInductance<num_complex::Complex32>> for &num_complex::Complex32 {
6660	type Output = InverseInductance<num_complex::Complex32>;
6661	fn mul(self, rhs: &InverseInductance<num_complex::Complex32>) -> Self::Output {
6662		InverseInductance{per_H: self.clone() * rhs.per_H.clone()}
6663	}
6664}
6665
6666/// Multiplying a unit value by a scalar value returns a unit value
6667#[cfg(feature="num-complex")]
6668impl core::ops::Mul<InverseInductance<num_complex::Complex64>> for num_complex::Complex64 {
6669	type Output = InverseInductance<num_complex::Complex64>;
6670	fn mul(self, rhs: InverseInductance<num_complex::Complex64>) -> Self::Output {
6671		InverseInductance{per_H: self * rhs.per_H}
6672	}
6673}
6674/// Multiplying a unit value by a scalar value returns a unit value
6675#[cfg(feature="num-complex")]
6676impl core::ops::Mul<InverseInductance<num_complex::Complex64>> for &num_complex::Complex64 {
6677	type Output = InverseInductance<num_complex::Complex64>;
6678	fn mul(self, rhs: InverseInductance<num_complex::Complex64>) -> Self::Output {
6679		InverseInductance{per_H: self.clone() * rhs.per_H}
6680	}
6681}
6682/// Multiplying a unit value by a scalar value returns a unit value
6683#[cfg(feature="num-complex")]
6684impl core::ops::Mul<&InverseInductance<num_complex::Complex64>> for num_complex::Complex64 {
6685	type Output = InverseInductance<num_complex::Complex64>;
6686	fn mul(self, rhs: &InverseInductance<num_complex::Complex64>) -> Self::Output {
6687		InverseInductance{per_H: self * rhs.per_H.clone()}
6688	}
6689}
6690/// Multiplying a unit value by a scalar value returns a unit value
6691#[cfg(feature="num-complex")]
6692impl core::ops::Mul<&InverseInductance<num_complex::Complex64>> for &num_complex::Complex64 {
6693	type Output = InverseInductance<num_complex::Complex64>;
6694	fn mul(self, rhs: &InverseInductance<num_complex::Complex64>) -> Self::Output {
6695		InverseInductance{per_H: self.clone() * rhs.per_H.clone()}
6696	}
6697}
6698
6699
6700
6701
6702// InverseInductance / Current -> InverseMagneticFlux
6703/// Dividing a InverseInductance by a Current returns a value of type InverseMagneticFlux
6704impl<T> core::ops::Div<Current<T>> for InverseInductance<T> where T: NumLike {
6705	type Output = InverseMagneticFlux<T>;
6706	fn div(self, rhs: Current<T>) -> Self::Output {
6707		InverseMagneticFlux{per_Wb: self.per_H / rhs.A}
6708	}
6709}
6710/// Dividing a InverseInductance by a Current returns a value of type InverseMagneticFlux
6711impl<T> core::ops::Div<Current<T>> for &InverseInductance<T> where T: NumLike {
6712	type Output = InverseMagneticFlux<T>;
6713	fn div(self, rhs: Current<T>) -> Self::Output {
6714		InverseMagneticFlux{per_Wb: self.per_H.clone() / rhs.A}
6715	}
6716}
6717/// Dividing a InverseInductance by a Current returns a value of type InverseMagneticFlux
6718impl<T> core::ops::Div<&Current<T>> for InverseInductance<T> where T: NumLike {
6719	type Output = InverseMagneticFlux<T>;
6720	fn div(self, rhs: &Current<T>) -> Self::Output {
6721		InverseMagneticFlux{per_Wb: self.per_H / rhs.A.clone()}
6722	}
6723}
6724/// Dividing a InverseInductance by a Current returns a value of type InverseMagneticFlux
6725impl<T> core::ops::Div<&Current<T>> for &InverseInductance<T> where T: NumLike {
6726	type Output = InverseMagneticFlux<T>;
6727	fn div(self, rhs: &Current<T>) -> Self::Output {
6728		InverseMagneticFlux{per_Wb: self.per_H.clone() / rhs.A.clone()}
6729	}
6730}
6731
6732// InverseInductance * InverseCurrent -> InverseMagneticFlux
6733/// Multiplying a InverseInductance by a InverseCurrent returns a value of type InverseMagneticFlux
6734impl<T> core::ops::Mul<InverseCurrent<T>> for InverseInductance<T> where T: NumLike {
6735	type Output = InverseMagneticFlux<T>;
6736	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
6737		InverseMagneticFlux{per_Wb: self.per_H * rhs.per_A}
6738	}
6739}
6740/// Multiplying a InverseInductance by a InverseCurrent returns a value of type InverseMagneticFlux
6741impl<T> core::ops::Mul<InverseCurrent<T>> for &InverseInductance<T> where T: NumLike {
6742	type Output = InverseMagneticFlux<T>;
6743	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
6744		InverseMagneticFlux{per_Wb: self.per_H.clone() * rhs.per_A}
6745	}
6746}
6747/// Multiplying a InverseInductance by a InverseCurrent returns a value of type InverseMagneticFlux
6748impl<T> core::ops::Mul<&InverseCurrent<T>> for InverseInductance<T> where T: NumLike {
6749	type Output = InverseMagneticFlux<T>;
6750	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
6751		InverseMagneticFlux{per_Wb: self.per_H * rhs.per_A.clone()}
6752	}
6753}
6754/// Multiplying a InverseInductance by a InverseCurrent returns a value of type InverseMagneticFlux
6755impl<T> core::ops::Mul<&InverseCurrent<T>> for &InverseInductance<T> where T: NumLike {
6756	type Output = InverseMagneticFlux<T>;
6757	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
6758		InverseMagneticFlux{per_Wb: self.per_H.clone() * rhs.per_A.clone()}
6759	}
6760}
6761
6762// InverseInductance * Time -> Conductance
6763/// Multiplying a InverseInductance by a Time returns a value of type Conductance
6764impl<T> core::ops::Mul<Time<T>> for InverseInductance<T> where T: NumLike {
6765	type Output = Conductance<T>;
6766	fn mul(self, rhs: Time<T>) -> Self::Output {
6767		Conductance{S: self.per_H * rhs.s}
6768	}
6769}
6770/// Multiplying a InverseInductance by a Time returns a value of type Conductance
6771impl<T> core::ops::Mul<Time<T>> for &InverseInductance<T> where T: NumLike {
6772	type Output = Conductance<T>;
6773	fn mul(self, rhs: Time<T>) -> Self::Output {
6774		Conductance{S: self.per_H.clone() * rhs.s}
6775	}
6776}
6777/// Multiplying a InverseInductance by a Time returns a value of type Conductance
6778impl<T> core::ops::Mul<&Time<T>> for InverseInductance<T> where T: NumLike {
6779	type Output = Conductance<T>;
6780	fn mul(self, rhs: &Time<T>) -> Self::Output {
6781		Conductance{S: self.per_H * rhs.s.clone()}
6782	}
6783}
6784/// Multiplying a InverseInductance by a Time returns a value of type Conductance
6785impl<T> core::ops::Mul<&Time<T>> for &InverseInductance<T> where T: NumLike {
6786	type Output = Conductance<T>;
6787	fn mul(self, rhs: &Time<T>) -> Self::Output {
6788		Conductance{S: self.per_H.clone() * rhs.s.clone()}
6789	}
6790}
6791
6792// InverseInductance / Conductance -> Frequency
6793/// Dividing a InverseInductance by a Conductance returns a value of type Frequency
6794impl<T> core::ops::Div<Conductance<T>> for InverseInductance<T> where T: NumLike {
6795	type Output = Frequency<T>;
6796	fn div(self, rhs: Conductance<T>) -> Self::Output {
6797		Frequency{Hz: self.per_H / rhs.S}
6798	}
6799}
6800/// Dividing a InverseInductance by a Conductance returns a value of type Frequency
6801impl<T> core::ops::Div<Conductance<T>> for &InverseInductance<T> where T: NumLike {
6802	type Output = Frequency<T>;
6803	fn div(self, rhs: Conductance<T>) -> Self::Output {
6804		Frequency{Hz: self.per_H.clone() / rhs.S}
6805	}
6806}
6807/// Dividing a InverseInductance by a Conductance returns a value of type Frequency
6808impl<T> core::ops::Div<&Conductance<T>> for InverseInductance<T> where T: NumLike {
6809	type Output = Frequency<T>;
6810	fn div(self, rhs: &Conductance<T>) -> Self::Output {
6811		Frequency{Hz: self.per_H / rhs.S.clone()}
6812	}
6813}
6814/// Dividing a InverseInductance by a Conductance returns a value of type Frequency
6815impl<T> core::ops::Div<&Conductance<T>> for &InverseInductance<T> where T: NumLike {
6816	type Output = Frequency<T>;
6817	fn div(self, rhs: &Conductance<T>) -> Self::Output {
6818		Frequency{Hz: self.per_H.clone() / rhs.S.clone()}
6819	}
6820}
6821
6822// InverseInductance / InverseMagneticFlux -> Current
6823/// Dividing a InverseInductance by a InverseMagneticFlux returns a value of type Current
6824impl<T> core::ops::Div<InverseMagneticFlux<T>> for InverseInductance<T> where T: NumLike {
6825	type Output = Current<T>;
6826	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
6827		Current{A: self.per_H / rhs.per_Wb}
6828	}
6829}
6830/// Dividing a InverseInductance by a InverseMagneticFlux returns a value of type Current
6831impl<T> core::ops::Div<InverseMagneticFlux<T>> for &InverseInductance<T> where T: NumLike {
6832	type Output = Current<T>;
6833	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
6834		Current{A: self.per_H.clone() / rhs.per_Wb}
6835	}
6836}
6837/// Dividing a InverseInductance by a InverseMagneticFlux returns a value of type Current
6838impl<T> core::ops::Div<&InverseMagneticFlux<T>> for InverseInductance<T> where T: NumLike {
6839	type Output = Current<T>;
6840	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
6841		Current{A: self.per_H / rhs.per_Wb.clone()}
6842	}
6843}
6844/// Dividing a InverseInductance by a InverseMagneticFlux returns a value of type Current
6845impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &InverseInductance<T> where T: NumLike {
6846	type Output = Current<T>;
6847	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
6848		Current{A: self.per_H.clone() / rhs.per_Wb.clone()}
6849	}
6850}
6851
6852// InverseInductance * MagneticFlux -> Current
6853/// Multiplying a InverseInductance by a MagneticFlux returns a value of type Current
6854impl<T> core::ops::Mul<MagneticFlux<T>> for InverseInductance<T> where T: NumLike {
6855	type Output = Current<T>;
6856	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
6857		Current{A: self.per_H * rhs.Wb}
6858	}
6859}
6860/// Multiplying a InverseInductance by a MagneticFlux returns a value of type Current
6861impl<T> core::ops::Mul<MagneticFlux<T>> for &InverseInductance<T> where T: NumLike {
6862	type Output = Current<T>;
6863	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
6864		Current{A: self.per_H.clone() * rhs.Wb}
6865	}
6866}
6867/// Multiplying a InverseInductance by a MagneticFlux returns a value of type Current
6868impl<T> core::ops::Mul<&MagneticFlux<T>> for InverseInductance<T> where T: NumLike {
6869	type Output = Current<T>;
6870	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
6871		Current{A: self.per_H * rhs.Wb.clone()}
6872	}
6873}
6874/// Multiplying a InverseInductance by a MagneticFlux returns a value of type Current
6875impl<T> core::ops::Mul<&MagneticFlux<T>> for &InverseInductance<T> where T: NumLike {
6876	type Output = Current<T>;
6877	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
6878		Current{A: self.per_H.clone() * rhs.Wb.clone()}
6879	}
6880}
6881
6882// InverseInductance * Resistance -> Frequency
6883/// Multiplying a InverseInductance by a Resistance returns a value of type Frequency
6884impl<T> core::ops::Mul<Resistance<T>> for InverseInductance<T> where T: NumLike {
6885	type Output = Frequency<T>;
6886	fn mul(self, rhs: Resistance<T>) -> Self::Output {
6887		Frequency{Hz: self.per_H * rhs.Ohm}
6888	}
6889}
6890/// Multiplying a InverseInductance by a Resistance returns a value of type Frequency
6891impl<T> core::ops::Mul<Resistance<T>> for &InverseInductance<T> where T: NumLike {
6892	type Output = Frequency<T>;
6893	fn mul(self, rhs: Resistance<T>) -> Self::Output {
6894		Frequency{Hz: self.per_H.clone() * rhs.Ohm}
6895	}
6896}
6897/// Multiplying a InverseInductance by a Resistance returns a value of type Frequency
6898impl<T> core::ops::Mul<&Resistance<T>> for InverseInductance<T> where T: NumLike {
6899	type Output = Frequency<T>;
6900	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
6901		Frequency{Hz: self.per_H * rhs.Ohm.clone()}
6902	}
6903}
6904/// Multiplying a InverseInductance by a Resistance returns a value of type Frequency
6905impl<T> core::ops::Mul<&Resistance<T>> for &InverseInductance<T> where T: NumLike {
6906	type Output = Frequency<T>;
6907	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
6908		Frequency{Hz: self.per_H.clone() * rhs.Ohm.clone()}
6909	}
6910}
6911
6912// InverseInductance / Frequency -> Conductance
6913/// Dividing a InverseInductance by a Frequency returns a value of type Conductance
6914impl<T> core::ops::Div<Frequency<T>> for InverseInductance<T> where T: NumLike {
6915	type Output = Conductance<T>;
6916	fn div(self, rhs: Frequency<T>) -> Self::Output {
6917		Conductance{S: self.per_H / rhs.Hz}
6918	}
6919}
6920/// Dividing a InverseInductance by a Frequency returns a value of type Conductance
6921impl<T> core::ops::Div<Frequency<T>> for &InverseInductance<T> where T: NumLike {
6922	type Output = Conductance<T>;
6923	fn div(self, rhs: Frequency<T>) -> Self::Output {
6924		Conductance{S: self.per_H.clone() / rhs.Hz}
6925	}
6926}
6927/// Dividing a InverseInductance by a Frequency returns a value of type Conductance
6928impl<T> core::ops::Div<&Frequency<T>> for InverseInductance<T> where T: NumLike {
6929	type Output = Conductance<T>;
6930	fn div(self, rhs: &Frequency<T>) -> Self::Output {
6931		Conductance{S: self.per_H / rhs.Hz.clone()}
6932	}
6933}
6934/// Dividing a InverseInductance by a Frequency returns a value of type Conductance
6935impl<T> core::ops::Div<&Frequency<T>> for &InverseInductance<T> where T: NumLike {
6936	type Output = Conductance<T>;
6937	fn div(self, rhs: &Frequency<T>) -> Self::Output {
6938		Conductance{S: self.per_H.clone() / rhs.Hz.clone()}
6939	}
6940}
6941
6942// 1/InverseInductance -> Inductance
6943/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6944impl<T> core::ops::Div<InverseInductance<T>> for f64 where T: NumLike+From<f64> {
6945	type Output = Inductance<T>;
6946	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
6947		Inductance{H: T::from(self) / rhs.per_H}
6948	}
6949}
6950/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6951impl<T> core::ops::Div<InverseInductance<T>> for &f64 where T: NumLike+From<f64> {
6952	type Output = Inductance<T>;
6953	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
6954		Inductance{H: T::from(self.clone()) / rhs.per_H}
6955	}
6956}
6957/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6958impl<T> core::ops::Div<&InverseInductance<T>> for f64 where T: NumLike+From<f64> {
6959	type Output = Inductance<T>;
6960	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
6961		Inductance{H: T::from(self) / rhs.per_H.clone()}
6962	}
6963}
6964/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6965impl<T> core::ops::Div<&InverseInductance<T>> for &f64 where T: NumLike+From<f64> {
6966	type Output = Inductance<T>;
6967	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
6968		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
6969	}
6970}
6971
6972// 1/InverseInductance -> Inductance
6973/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6974impl<T> core::ops::Div<InverseInductance<T>> for f32 where T: NumLike+From<f32> {
6975	type Output = Inductance<T>;
6976	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
6977		Inductance{H: T::from(self) / rhs.per_H}
6978	}
6979}
6980/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6981impl<T> core::ops::Div<InverseInductance<T>> for &f32 where T: NumLike+From<f32> {
6982	type Output = Inductance<T>;
6983	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
6984		Inductance{H: T::from(self.clone()) / rhs.per_H}
6985	}
6986}
6987/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6988impl<T> core::ops::Div<&InverseInductance<T>> for f32 where T: NumLike+From<f32> {
6989	type Output = Inductance<T>;
6990	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
6991		Inductance{H: T::from(self) / rhs.per_H.clone()}
6992	}
6993}
6994/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
6995impl<T> core::ops::Div<&InverseInductance<T>> for &f32 where T: NumLike+From<f32> {
6996	type Output = Inductance<T>;
6997	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
6998		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
6999	}
7000}
7001
7002// 1/InverseInductance -> Inductance
7003/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7004impl<T> core::ops::Div<InverseInductance<T>> for i64 where T: NumLike+From<i64> {
7005	type Output = Inductance<T>;
7006	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7007		Inductance{H: T::from(self) / rhs.per_H}
7008	}
7009}
7010/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7011impl<T> core::ops::Div<InverseInductance<T>> for &i64 where T: NumLike+From<i64> {
7012	type Output = Inductance<T>;
7013	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7014		Inductance{H: T::from(self.clone()) / rhs.per_H}
7015	}
7016}
7017/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7018impl<T> core::ops::Div<&InverseInductance<T>> for i64 where T: NumLike+From<i64> {
7019	type Output = Inductance<T>;
7020	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7021		Inductance{H: T::from(self) / rhs.per_H.clone()}
7022	}
7023}
7024/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7025impl<T> core::ops::Div<&InverseInductance<T>> for &i64 where T: NumLike+From<i64> {
7026	type Output = Inductance<T>;
7027	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7028		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
7029	}
7030}
7031
7032// 1/InverseInductance -> Inductance
7033/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7034impl<T> core::ops::Div<InverseInductance<T>> for i32 where T: NumLike+From<i32> {
7035	type Output = Inductance<T>;
7036	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7037		Inductance{H: T::from(self) / rhs.per_H}
7038	}
7039}
7040/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7041impl<T> core::ops::Div<InverseInductance<T>> for &i32 where T: NumLike+From<i32> {
7042	type Output = Inductance<T>;
7043	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7044		Inductance{H: T::from(self.clone()) / rhs.per_H}
7045	}
7046}
7047/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7048impl<T> core::ops::Div<&InverseInductance<T>> for i32 where T: NumLike+From<i32> {
7049	type Output = Inductance<T>;
7050	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7051		Inductance{H: T::from(self) / rhs.per_H.clone()}
7052	}
7053}
7054/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7055impl<T> core::ops::Div<&InverseInductance<T>> for &i32 where T: NumLike+From<i32> {
7056	type Output = Inductance<T>;
7057	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7058		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
7059	}
7060}
7061
7062// 1/InverseInductance -> Inductance
7063/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7064#[cfg(feature="num-bigfloat")]
7065impl<T> core::ops::Div<InverseInductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7066	type Output = Inductance<T>;
7067	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7068		Inductance{H: T::from(self) / rhs.per_H}
7069	}
7070}
7071/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7072#[cfg(feature="num-bigfloat")]
7073impl<T> core::ops::Div<InverseInductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7074	type Output = Inductance<T>;
7075	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7076		Inductance{H: T::from(self.clone()) / rhs.per_H}
7077	}
7078}
7079/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7080#[cfg(feature="num-bigfloat")]
7081impl<T> core::ops::Div<&InverseInductance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7082	type Output = Inductance<T>;
7083	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7084		Inductance{H: T::from(self) / rhs.per_H.clone()}
7085	}
7086}
7087/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7088#[cfg(feature="num-bigfloat")]
7089impl<T> core::ops::Div<&InverseInductance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7090	type Output = Inductance<T>;
7091	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7092		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
7093	}
7094}
7095
7096// 1/InverseInductance -> Inductance
7097/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7098#[cfg(feature="num-complex")]
7099impl<T> core::ops::Div<InverseInductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7100	type Output = Inductance<T>;
7101	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7102		Inductance{H: T::from(self) / rhs.per_H}
7103	}
7104}
7105/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7106#[cfg(feature="num-complex")]
7107impl<T> core::ops::Div<InverseInductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7108	type Output = Inductance<T>;
7109	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7110		Inductance{H: T::from(self.clone()) / rhs.per_H}
7111	}
7112}
7113/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7114#[cfg(feature="num-complex")]
7115impl<T> core::ops::Div<&InverseInductance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7116	type Output = Inductance<T>;
7117	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7118		Inductance{H: T::from(self) / rhs.per_H.clone()}
7119	}
7120}
7121/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7122#[cfg(feature="num-complex")]
7123impl<T> core::ops::Div<&InverseInductance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7124	type Output = Inductance<T>;
7125	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7126		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
7127	}
7128}
7129
7130// 1/InverseInductance -> Inductance
7131/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7132#[cfg(feature="num-complex")]
7133impl<T> core::ops::Div<InverseInductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7134	type Output = Inductance<T>;
7135	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7136		Inductance{H: T::from(self) / rhs.per_H}
7137	}
7138}
7139/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7140#[cfg(feature="num-complex")]
7141impl<T> core::ops::Div<InverseInductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7142	type Output = Inductance<T>;
7143	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
7144		Inductance{H: T::from(self.clone()) / rhs.per_H}
7145	}
7146}
7147/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7148#[cfg(feature="num-complex")]
7149impl<T> core::ops::Div<&InverseInductance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7150	type Output = Inductance<T>;
7151	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7152		Inductance{H: T::from(self) / rhs.per_H.clone()}
7153	}
7154}
7155/// Dividing a scalar value by a InverseInductance unit value returns a value of type Inductance
7156#[cfg(feature="num-complex")]
7157impl<T> core::ops::Div<&InverseInductance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7158	type Output = Inductance<T>;
7159	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
7160		Inductance{H: T::from(self.clone()) / rhs.per_H.clone()}
7161	}
7162}
7163
7164/// The inverse of luminous flux unit type, defined as inverse lumens in SI units
7165#[derive(UnitStruct, Debug, Clone)]
7166#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
7167pub struct InverseLuminousFlux<T: NumLike>{
7168	/// The value of this Inverse luminous flux in inverse lumens
7169	pub per_lm: T
7170}
7171
7172impl<T> InverseLuminousFlux<T> where T: NumLike {
7173
7174	/// Returns the standard unit name of inverse luminous flux: "inverse lumens"
7175	pub fn unit_name() -> &'static str { "inverse lumens" }
7176	
7177	/// Returns the abbreviated name or symbol of inverse luminous flux: "1/lm" for inverse lumens
7178	pub fn unit_symbol() -> &'static str { "1/lm" }
7179	
7180	/// Returns a new inverse luminous flux value from the given number of inverse lumens
7181	///
7182	/// # Arguments
7183	/// * `per_lm` - Any number-like type, representing a quantity of inverse lumens
7184	pub fn from_per_lm(per_lm: T) -> Self { InverseLuminousFlux{per_lm: per_lm} }
7185	
7186	/// Returns a copy of this inverse luminous flux value in inverse lumens
7187	pub fn to_per_lm(&self) -> T { self.per_lm.clone() }
7188
7189	/// Returns a new inverse luminous flux value from the given number of inverse lumens
7190	///
7191	/// # Arguments
7192	/// * `per_lumens` - Any number-like type, representing a quantity of inverse lumens
7193	pub fn from_per_lumens(per_lumens: T) -> Self { InverseLuminousFlux{per_lm: per_lumens} }
7194	
7195	/// Returns a copy of this inverse luminous flux value in inverse lumens
7196	pub fn to_per_lumens(&self) -> T { self.per_lm.clone() }
7197
7198}
7199
7200impl<T> fmt::Display for InverseLuminousFlux<T> where T: NumLike {
7201	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7202		write!(f, "{} {}", &self.per_lm, Self::unit_symbol())
7203	}
7204}
7205
7206impl<T> InverseLuminousFlux<T> where T: NumLike+From<f64> {
7207	
7208	/// Returns a copy of this inverse luminous flux value in inverse millilumens
7209	/// 
7210	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7211	pub fn to_per_mlm(&self) -> T {
7212		return self.per_lm.clone() * T::from(0.001_f64);
7213	}
7214
7215	/// Returns a new inverse luminous flux value from the given number of inverse millilumens
7216	/// 
7217	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7218	///
7219	/// # Arguments
7220	/// * `per_mlm` - Any number-like type, representing a quantity of inverse millilumens
7221	pub fn from_per_mlm(per_mlm: T) -> Self {
7222		InverseLuminousFlux{per_lm: per_mlm * T::from(1000.0_f64)}
7223	}
7224
7225	/// Returns a copy of this inverse luminous flux value in inverse microlumens
7226	/// 
7227	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7228	pub fn to_per_ulm(&self) -> T {
7229		return self.per_lm.clone() * T::from(1e-06_f64);
7230	}
7231
7232	/// Returns a new inverse luminous flux value from the given number of inverse microlumens
7233	/// 
7234	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7235	///
7236	/// # Arguments
7237	/// * `per_ulm` - Any number-like type, representing a quantity of inverse microlumens
7238	pub fn from_per_ulm(per_ulm: T) -> Self {
7239		InverseLuminousFlux{per_lm: per_ulm * T::from(1000000.0_f64)}
7240	}
7241
7242	/// Returns a copy of this inverse luminous flux value in inverse nanolumens
7243	/// 
7244	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7245	pub fn to_per_nlm(&self) -> T {
7246		return self.per_lm.clone() * T::from(1e-09_f64);
7247	}
7248
7249	/// Returns a new inverse luminous flux value from the given number of inverse nanolumens
7250	/// 
7251	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7252	///
7253	/// # Arguments
7254	/// * `per_nlm` - Any number-like type, representing a quantity of inverse nanolumens
7255	pub fn from_per_nlm(per_nlm: T) -> Self {
7256		InverseLuminousFlux{per_lm: per_nlm * T::from(1000000000.0_f64)}
7257	}
7258
7259	/// Returns a copy of this inverse luminous flux value in inverse kilolumens
7260	/// 
7261	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7262	pub fn to_per_klm(&self) -> T {
7263		return self.per_lm.clone() * T::from(1000.0_f64);
7264	}
7265
7266	/// Returns a new inverse luminous flux value from the given number of inverse kilolumens
7267	/// 
7268	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7269	///
7270	/// # Arguments
7271	/// * `per_klm` - Any number-like type, representing a quantity of inverse kilolumens
7272	pub fn from_per_klm(per_klm: T) -> Self {
7273		InverseLuminousFlux{per_lm: per_klm * T::from(0.001_f64)}
7274	}
7275
7276	/// Returns a copy of this inverse luminous flux value in inverse megalumens
7277	/// 
7278	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7279	pub fn to_per_Mlm(&self) -> T {
7280		return self.per_lm.clone() * T::from(1000000.0_f64);
7281	}
7282
7283	/// Returns a new inverse luminous flux value from the given number of inverse megalumens
7284	/// 
7285	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7286	///
7287	/// # Arguments
7288	/// * `per_Mlm` - Any number-like type, representing a quantity of inverse megalumens
7289	pub fn from_per_Mlm(per_Mlm: T) -> Self {
7290		InverseLuminousFlux{per_lm: per_Mlm * T::from(1e-06_f64)}
7291	}
7292
7293	/// Returns a copy of this inverse luminous flux value in inverse gigalumens
7294	/// 
7295	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7296	pub fn to_per_Glm(&self) -> T {
7297		return self.per_lm.clone() * T::from(1000000000.0_f64);
7298	}
7299
7300	/// Returns a new inverse luminous flux value from the given number of inverse gigalumens
7301	/// 
7302	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7303	///
7304	/// # Arguments
7305	/// * `per_Glm` - Any number-like type, representing a quantity of inverse gigalumens
7306	pub fn from_per_Glm(per_Glm: T) -> Self {
7307		InverseLuminousFlux{per_lm: per_Glm * T::from(1e-09_f64)}
7308	}
7309
7310}
7311
7312
7313/// Multiplying a unit value by a scalar value returns a unit value
7314#[cfg(feature="num-bigfloat")]
7315impl core::ops::Mul<InverseLuminousFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
7316	type Output = InverseLuminousFlux<num_bigfloat::BigFloat>;
7317	fn mul(self, rhs: InverseLuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
7318		InverseLuminousFlux{per_lm: self * rhs.per_lm}
7319	}
7320}
7321/// Multiplying a unit value by a scalar value returns a unit value
7322#[cfg(feature="num-bigfloat")]
7323impl core::ops::Mul<InverseLuminousFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
7324	type Output = InverseLuminousFlux<num_bigfloat::BigFloat>;
7325	fn mul(self, rhs: InverseLuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
7326		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm}
7327	}
7328}
7329/// Multiplying a unit value by a scalar value returns a unit value
7330#[cfg(feature="num-bigfloat")]
7331impl core::ops::Mul<&InverseLuminousFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
7332	type Output = InverseLuminousFlux<num_bigfloat::BigFloat>;
7333	fn mul(self, rhs: &InverseLuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
7334		InverseLuminousFlux{per_lm: self * rhs.per_lm.clone()}
7335	}
7336}
7337/// Multiplying a unit value by a scalar value returns a unit value
7338#[cfg(feature="num-bigfloat")]
7339impl core::ops::Mul<&InverseLuminousFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
7340	type Output = InverseLuminousFlux<num_bigfloat::BigFloat>;
7341	fn mul(self, rhs: &InverseLuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
7342		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm.clone()}
7343	}
7344}
7345
7346/// Multiplying a unit value by a scalar value returns a unit value
7347#[cfg(feature="num-complex")]
7348impl core::ops::Mul<InverseLuminousFlux<num_complex::Complex32>> for num_complex::Complex32 {
7349	type Output = InverseLuminousFlux<num_complex::Complex32>;
7350	fn mul(self, rhs: InverseLuminousFlux<num_complex::Complex32>) -> Self::Output {
7351		InverseLuminousFlux{per_lm: self * rhs.per_lm}
7352	}
7353}
7354/// Multiplying a unit value by a scalar value returns a unit value
7355#[cfg(feature="num-complex")]
7356impl core::ops::Mul<InverseLuminousFlux<num_complex::Complex32>> for &num_complex::Complex32 {
7357	type Output = InverseLuminousFlux<num_complex::Complex32>;
7358	fn mul(self, rhs: InverseLuminousFlux<num_complex::Complex32>) -> Self::Output {
7359		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm}
7360	}
7361}
7362/// Multiplying a unit value by a scalar value returns a unit value
7363#[cfg(feature="num-complex")]
7364impl core::ops::Mul<&InverseLuminousFlux<num_complex::Complex32>> for num_complex::Complex32 {
7365	type Output = InverseLuminousFlux<num_complex::Complex32>;
7366	fn mul(self, rhs: &InverseLuminousFlux<num_complex::Complex32>) -> Self::Output {
7367		InverseLuminousFlux{per_lm: self * rhs.per_lm.clone()}
7368	}
7369}
7370/// Multiplying a unit value by a scalar value returns a unit value
7371#[cfg(feature="num-complex")]
7372impl core::ops::Mul<&InverseLuminousFlux<num_complex::Complex32>> for &num_complex::Complex32 {
7373	type Output = InverseLuminousFlux<num_complex::Complex32>;
7374	fn mul(self, rhs: &InverseLuminousFlux<num_complex::Complex32>) -> Self::Output {
7375		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm.clone()}
7376	}
7377}
7378
7379/// Multiplying a unit value by a scalar value returns a unit value
7380#[cfg(feature="num-complex")]
7381impl core::ops::Mul<InverseLuminousFlux<num_complex::Complex64>> for num_complex::Complex64 {
7382	type Output = InverseLuminousFlux<num_complex::Complex64>;
7383	fn mul(self, rhs: InverseLuminousFlux<num_complex::Complex64>) -> Self::Output {
7384		InverseLuminousFlux{per_lm: self * rhs.per_lm}
7385	}
7386}
7387/// Multiplying a unit value by a scalar value returns a unit value
7388#[cfg(feature="num-complex")]
7389impl core::ops::Mul<InverseLuminousFlux<num_complex::Complex64>> for &num_complex::Complex64 {
7390	type Output = InverseLuminousFlux<num_complex::Complex64>;
7391	fn mul(self, rhs: InverseLuminousFlux<num_complex::Complex64>) -> Self::Output {
7392		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm}
7393	}
7394}
7395/// Multiplying a unit value by a scalar value returns a unit value
7396#[cfg(feature="num-complex")]
7397impl core::ops::Mul<&InverseLuminousFlux<num_complex::Complex64>> for num_complex::Complex64 {
7398	type Output = InverseLuminousFlux<num_complex::Complex64>;
7399	fn mul(self, rhs: &InverseLuminousFlux<num_complex::Complex64>) -> Self::Output {
7400		InverseLuminousFlux{per_lm: self * rhs.per_lm.clone()}
7401	}
7402}
7403/// Multiplying a unit value by a scalar value returns a unit value
7404#[cfg(feature="num-complex")]
7405impl core::ops::Mul<&InverseLuminousFlux<num_complex::Complex64>> for &num_complex::Complex64 {
7406	type Output = InverseLuminousFlux<num_complex::Complex64>;
7407	fn mul(self, rhs: &InverseLuminousFlux<num_complex::Complex64>) -> Self::Output {
7408		InverseLuminousFlux{per_lm: self.clone() * rhs.per_lm.clone()}
7409	}
7410}
7411
7412
7413
7414
7415// InverseLuminousFlux / InverseLuminosity -> InverseSolidAngle
7416/// Dividing a InverseLuminousFlux by a InverseLuminosity returns a value of type InverseSolidAngle
7417impl<T> core::ops::Div<InverseLuminosity<T>> for InverseLuminousFlux<T> where T: NumLike {
7418	type Output = InverseSolidAngle<T>;
7419	fn div(self, rhs: InverseLuminosity<T>) -> Self::Output {
7420		InverseSolidAngle{per_sr: self.per_lm / rhs.per_cd}
7421	}
7422}
7423/// Dividing a InverseLuminousFlux by a InverseLuminosity returns a value of type InverseSolidAngle
7424impl<T> core::ops::Div<InverseLuminosity<T>> for &InverseLuminousFlux<T> where T: NumLike {
7425	type Output = InverseSolidAngle<T>;
7426	fn div(self, rhs: InverseLuminosity<T>) -> Self::Output {
7427		InverseSolidAngle{per_sr: self.per_lm.clone() / rhs.per_cd}
7428	}
7429}
7430/// Dividing a InverseLuminousFlux by a InverseLuminosity returns a value of type InverseSolidAngle
7431impl<T> core::ops::Div<&InverseLuminosity<T>> for InverseLuminousFlux<T> where T: NumLike {
7432	type Output = InverseSolidAngle<T>;
7433	fn div(self, rhs: &InverseLuminosity<T>) -> Self::Output {
7434		InverseSolidAngle{per_sr: self.per_lm / rhs.per_cd.clone()}
7435	}
7436}
7437/// Dividing a InverseLuminousFlux by a InverseLuminosity returns a value of type InverseSolidAngle
7438impl<T> core::ops::Div<&InverseLuminosity<T>> for &InverseLuminousFlux<T> where T: NumLike {
7439	type Output = InverseSolidAngle<T>;
7440	fn div(self, rhs: &InverseLuminosity<T>) -> Self::Output {
7441		InverseSolidAngle{per_sr: self.per_lm.clone() / rhs.per_cd.clone()}
7442	}
7443}
7444
7445// InverseLuminousFlux * Luminosity -> InverseSolidAngle
7446/// Multiplying a InverseLuminousFlux by a Luminosity returns a value of type InverseSolidAngle
7447impl<T> core::ops::Mul<Luminosity<T>> for InverseLuminousFlux<T> where T: NumLike {
7448	type Output = InverseSolidAngle<T>;
7449	fn mul(self, rhs: Luminosity<T>) -> Self::Output {
7450		InverseSolidAngle{per_sr: self.per_lm * rhs.cd}
7451	}
7452}
7453/// Multiplying a InverseLuminousFlux by a Luminosity returns a value of type InverseSolidAngle
7454impl<T> core::ops::Mul<Luminosity<T>> for &InverseLuminousFlux<T> where T: NumLike {
7455	type Output = InverseSolidAngle<T>;
7456	fn mul(self, rhs: Luminosity<T>) -> Self::Output {
7457		InverseSolidAngle{per_sr: self.per_lm.clone() * rhs.cd}
7458	}
7459}
7460/// Multiplying a InverseLuminousFlux by a Luminosity returns a value of type InverseSolidAngle
7461impl<T> core::ops::Mul<&Luminosity<T>> for InverseLuminousFlux<T> where T: NumLike {
7462	type Output = InverseSolidAngle<T>;
7463	fn mul(self, rhs: &Luminosity<T>) -> Self::Output {
7464		InverseSolidAngle{per_sr: self.per_lm * rhs.cd.clone()}
7465	}
7466}
7467/// Multiplying a InverseLuminousFlux by a Luminosity returns a value of type InverseSolidAngle
7468impl<T> core::ops::Mul<&Luminosity<T>> for &InverseLuminousFlux<T> where T: NumLike {
7469	type Output = InverseSolidAngle<T>;
7470	fn mul(self, rhs: &Luminosity<T>) -> Self::Output {
7471		InverseSolidAngle{per_sr: self.per_lm.clone() * rhs.cd.clone()}
7472	}
7473}
7474
7475// InverseLuminousFlux / AreaPerLumen -> InverseArea
7476/// Dividing a InverseLuminousFlux by a AreaPerLumen returns a value of type InverseArea
7477impl<T> core::ops::Div<AreaPerLumen<T>> for InverseLuminousFlux<T> where T: NumLike {
7478	type Output = InverseArea<T>;
7479	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
7480		InverseArea{per_m2: self.per_lm / rhs.m2_per_lm}
7481	}
7482}
7483/// Dividing a InverseLuminousFlux by a AreaPerLumen returns a value of type InverseArea
7484impl<T> core::ops::Div<AreaPerLumen<T>> for &InverseLuminousFlux<T> where T: NumLike {
7485	type Output = InverseArea<T>;
7486	fn div(self, rhs: AreaPerLumen<T>) -> Self::Output {
7487		InverseArea{per_m2: self.per_lm.clone() / rhs.m2_per_lm}
7488	}
7489}
7490/// Dividing a InverseLuminousFlux by a AreaPerLumen returns a value of type InverseArea
7491impl<T> core::ops::Div<&AreaPerLumen<T>> for InverseLuminousFlux<T> where T: NumLike {
7492	type Output = InverseArea<T>;
7493	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
7494		InverseArea{per_m2: self.per_lm / rhs.m2_per_lm.clone()}
7495	}
7496}
7497/// Dividing a InverseLuminousFlux by a AreaPerLumen returns a value of type InverseArea
7498impl<T> core::ops::Div<&AreaPerLumen<T>> for &InverseLuminousFlux<T> where T: NumLike {
7499	type Output = InverseArea<T>;
7500	fn div(self, rhs: &AreaPerLumen<T>) -> Self::Output {
7501		InverseArea{per_m2: self.per_lm.clone() / rhs.m2_per_lm.clone()}
7502	}
7503}
7504
7505// InverseLuminousFlux * Illuminance -> InverseArea
7506/// Multiplying a InverseLuminousFlux by a Illuminance returns a value of type InverseArea
7507impl<T> core::ops::Mul<Illuminance<T>> for InverseLuminousFlux<T> where T: NumLike {
7508	type Output = InverseArea<T>;
7509	fn mul(self, rhs: Illuminance<T>) -> Self::Output {
7510		InverseArea{per_m2: self.per_lm * rhs.lux}
7511	}
7512}
7513/// Multiplying a InverseLuminousFlux by a Illuminance returns a value of type InverseArea
7514impl<T> core::ops::Mul<Illuminance<T>> for &InverseLuminousFlux<T> where T: NumLike {
7515	type Output = InverseArea<T>;
7516	fn mul(self, rhs: Illuminance<T>) -> Self::Output {
7517		InverseArea{per_m2: self.per_lm.clone() * rhs.lux}
7518	}
7519}
7520/// Multiplying a InverseLuminousFlux by a Illuminance returns a value of type InverseArea
7521impl<T> core::ops::Mul<&Illuminance<T>> for InverseLuminousFlux<T> where T: NumLike {
7522	type Output = InverseArea<T>;
7523	fn mul(self, rhs: &Illuminance<T>) -> Self::Output {
7524		InverseArea{per_m2: self.per_lm * rhs.lux.clone()}
7525	}
7526}
7527/// Multiplying a InverseLuminousFlux by a Illuminance returns a value of type InverseArea
7528impl<T> core::ops::Mul<&Illuminance<T>> for &InverseLuminousFlux<T> where T: NumLike {
7529	type Output = InverseArea<T>;
7530	fn mul(self, rhs: &Illuminance<T>) -> Self::Output {
7531		InverseArea{per_m2: self.per_lm.clone() * rhs.lux.clone()}
7532	}
7533}
7534
7535// InverseLuminousFlux * Area -> AreaPerLumen
7536/// Multiplying a InverseLuminousFlux by a Area returns a value of type AreaPerLumen
7537impl<T> core::ops::Mul<Area<T>> for InverseLuminousFlux<T> where T: NumLike {
7538	type Output = AreaPerLumen<T>;
7539	fn mul(self, rhs: Area<T>) -> Self::Output {
7540		AreaPerLumen{m2_per_lm: self.per_lm * rhs.m2}
7541	}
7542}
7543/// Multiplying a InverseLuminousFlux by a Area returns a value of type AreaPerLumen
7544impl<T> core::ops::Mul<Area<T>> for &InverseLuminousFlux<T> where T: NumLike {
7545	type Output = AreaPerLumen<T>;
7546	fn mul(self, rhs: Area<T>) -> Self::Output {
7547		AreaPerLumen{m2_per_lm: self.per_lm.clone() * rhs.m2}
7548	}
7549}
7550/// Multiplying a InverseLuminousFlux by a Area returns a value of type AreaPerLumen
7551impl<T> core::ops::Mul<&Area<T>> for InverseLuminousFlux<T> where T: NumLike {
7552	type Output = AreaPerLumen<T>;
7553	fn mul(self, rhs: &Area<T>) -> Self::Output {
7554		AreaPerLumen{m2_per_lm: self.per_lm * rhs.m2.clone()}
7555	}
7556}
7557/// Multiplying a InverseLuminousFlux by a Area returns a value of type AreaPerLumen
7558impl<T> core::ops::Mul<&Area<T>> for &InverseLuminousFlux<T> where T: NumLike {
7559	type Output = AreaPerLumen<T>;
7560	fn mul(self, rhs: &Area<T>) -> Self::Output {
7561		AreaPerLumen{m2_per_lm: self.per_lm.clone() * rhs.m2.clone()}
7562	}
7563}
7564
7565// InverseLuminousFlux / InverseArea -> AreaPerLumen
7566/// Dividing a InverseLuminousFlux by a InverseArea returns a value of type AreaPerLumen
7567impl<T> core::ops::Div<InverseArea<T>> for InverseLuminousFlux<T> where T: NumLike {
7568	type Output = AreaPerLumen<T>;
7569	fn div(self, rhs: InverseArea<T>) -> Self::Output {
7570		AreaPerLumen{m2_per_lm: self.per_lm / rhs.per_m2}
7571	}
7572}
7573/// Dividing a InverseLuminousFlux by a InverseArea returns a value of type AreaPerLumen
7574impl<T> core::ops::Div<InverseArea<T>> for &InverseLuminousFlux<T> where T: NumLike {
7575	type Output = AreaPerLumen<T>;
7576	fn div(self, rhs: InverseArea<T>) -> Self::Output {
7577		AreaPerLumen{m2_per_lm: self.per_lm.clone() / rhs.per_m2}
7578	}
7579}
7580/// Dividing a InverseLuminousFlux by a InverseArea returns a value of type AreaPerLumen
7581impl<T> core::ops::Div<&InverseArea<T>> for InverseLuminousFlux<T> where T: NumLike {
7582	type Output = AreaPerLumen<T>;
7583	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
7584		AreaPerLumen{m2_per_lm: self.per_lm / rhs.per_m2.clone()}
7585	}
7586}
7587/// Dividing a InverseLuminousFlux by a InverseArea returns a value of type AreaPerLumen
7588impl<T> core::ops::Div<&InverseArea<T>> for &InverseLuminousFlux<T> where T: NumLike {
7589	type Output = AreaPerLumen<T>;
7590	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
7591		AreaPerLumen{m2_per_lm: self.per_lm.clone() / rhs.per_m2.clone()}
7592	}
7593}
7594
7595// InverseLuminousFlux / InverseSolidAngle -> InverseLuminosity
7596/// Dividing a InverseLuminousFlux by a InverseSolidAngle returns a value of type InverseLuminosity
7597impl<T> core::ops::Div<InverseSolidAngle<T>> for InverseLuminousFlux<T> where T: NumLike {
7598	type Output = InverseLuminosity<T>;
7599	fn div(self, rhs: InverseSolidAngle<T>) -> Self::Output {
7600		InverseLuminosity{per_cd: self.per_lm / rhs.per_sr}
7601	}
7602}
7603/// Dividing a InverseLuminousFlux by a InverseSolidAngle returns a value of type InverseLuminosity
7604impl<T> core::ops::Div<InverseSolidAngle<T>> for &InverseLuminousFlux<T> where T: NumLike {
7605	type Output = InverseLuminosity<T>;
7606	fn div(self, rhs: InverseSolidAngle<T>) -> Self::Output {
7607		InverseLuminosity{per_cd: self.per_lm.clone() / rhs.per_sr}
7608	}
7609}
7610/// Dividing a InverseLuminousFlux by a InverseSolidAngle returns a value of type InverseLuminosity
7611impl<T> core::ops::Div<&InverseSolidAngle<T>> for InverseLuminousFlux<T> where T: NumLike {
7612	type Output = InverseLuminosity<T>;
7613	fn div(self, rhs: &InverseSolidAngle<T>) -> Self::Output {
7614		InverseLuminosity{per_cd: self.per_lm / rhs.per_sr.clone()}
7615	}
7616}
7617/// Dividing a InverseLuminousFlux by a InverseSolidAngle returns a value of type InverseLuminosity
7618impl<T> core::ops::Div<&InverseSolidAngle<T>> for &InverseLuminousFlux<T> where T: NumLike {
7619	type Output = InverseLuminosity<T>;
7620	fn div(self, rhs: &InverseSolidAngle<T>) -> Self::Output {
7621		InverseLuminosity{per_cd: self.per_lm.clone() / rhs.per_sr.clone()}
7622	}
7623}
7624
7625// InverseLuminousFlux * SolidAngle -> InverseLuminosity
7626/// Multiplying a InverseLuminousFlux by a SolidAngle returns a value of type InverseLuminosity
7627impl<T> core::ops::Mul<SolidAngle<T>> for InverseLuminousFlux<T> where T: NumLike {
7628	type Output = InverseLuminosity<T>;
7629	fn mul(self, rhs: SolidAngle<T>) -> Self::Output {
7630		InverseLuminosity{per_cd: self.per_lm * rhs.sr}
7631	}
7632}
7633/// Multiplying a InverseLuminousFlux by a SolidAngle returns a value of type InverseLuminosity
7634impl<T> core::ops::Mul<SolidAngle<T>> for &InverseLuminousFlux<T> where T: NumLike {
7635	type Output = InverseLuminosity<T>;
7636	fn mul(self, rhs: SolidAngle<T>) -> Self::Output {
7637		InverseLuminosity{per_cd: self.per_lm.clone() * rhs.sr}
7638	}
7639}
7640/// Multiplying a InverseLuminousFlux by a SolidAngle returns a value of type InverseLuminosity
7641impl<T> core::ops::Mul<&SolidAngle<T>> for InverseLuminousFlux<T> where T: NumLike {
7642	type Output = InverseLuminosity<T>;
7643	fn mul(self, rhs: &SolidAngle<T>) -> Self::Output {
7644		InverseLuminosity{per_cd: self.per_lm * rhs.sr.clone()}
7645	}
7646}
7647/// Multiplying a InverseLuminousFlux by a SolidAngle returns a value of type InverseLuminosity
7648impl<T> core::ops::Mul<&SolidAngle<T>> for &InverseLuminousFlux<T> where T: NumLike {
7649	type Output = InverseLuminosity<T>;
7650	fn mul(self, rhs: &SolidAngle<T>) -> Self::Output {
7651		InverseLuminosity{per_cd: self.per_lm.clone() * rhs.sr.clone()}
7652	}
7653}
7654
7655// 1/InverseLuminousFlux -> LuminousFlux
7656/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7657impl<T> core::ops::Div<InverseLuminousFlux<T>> for f64 where T: NumLike+From<f64> {
7658	type Output = LuminousFlux<T>;
7659	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7660		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7661	}
7662}
7663/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7664impl<T> core::ops::Div<InverseLuminousFlux<T>> for &f64 where T: NumLike+From<f64> {
7665	type Output = LuminousFlux<T>;
7666	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7667		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7668	}
7669}
7670/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7671impl<T> core::ops::Div<&InverseLuminousFlux<T>> for f64 where T: NumLike+From<f64> {
7672	type Output = LuminousFlux<T>;
7673	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7674		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7675	}
7676}
7677/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7678impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &f64 where T: NumLike+From<f64> {
7679	type Output = LuminousFlux<T>;
7680	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7681		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7682	}
7683}
7684
7685// 1/InverseLuminousFlux -> LuminousFlux
7686/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7687impl<T> core::ops::Div<InverseLuminousFlux<T>> for f32 where T: NumLike+From<f32> {
7688	type Output = LuminousFlux<T>;
7689	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7690		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7691	}
7692}
7693/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7694impl<T> core::ops::Div<InverseLuminousFlux<T>> for &f32 where T: NumLike+From<f32> {
7695	type Output = LuminousFlux<T>;
7696	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7697		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7698	}
7699}
7700/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7701impl<T> core::ops::Div<&InverseLuminousFlux<T>> for f32 where T: NumLike+From<f32> {
7702	type Output = LuminousFlux<T>;
7703	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7704		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7705	}
7706}
7707/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7708impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &f32 where T: NumLike+From<f32> {
7709	type Output = LuminousFlux<T>;
7710	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7711		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7712	}
7713}
7714
7715// 1/InverseLuminousFlux -> LuminousFlux
7716/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7717impl<T> core::ops::Div<InverseLuminousFlux<T>> for i64 where T: NumLike+From<i64> {
7718	type Output = LuminousFlux<T>;
7719	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7720		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7721	}
7722}
7723/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7724impl<T> core::ops::Div<InverseLuminousFlux<T>> for &i64 where T: NumLike+From<i64> {
7725	type Output = LuminousFlux<T>;
7726	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7727		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7728	}
7729}
7730/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7731impl<T> core::ops::Div<&InverseLuminousFlux<T>> for i64 where T: NumLike+From<i64> {
7732	type Output = LuminousFlux<T>;
7733	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7734		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7735	}
7736}
7737/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7738impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &i64 where T: NumLike+From<i64> {
7739	type Output = LuminousFlux<T>;
7740	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7741		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7742	}
7743}
7744
7745// 1/InverseLuminousFlux -> LuminousFlux
7746/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7747impl<T> core::ops::Div<InverseLuminousFlux<T>> for i32 where T: NumLike+From<i32> {
7748	type Output = LuminousFlux<T>;
7749	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7750		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7751	}
7752}
7753/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7754impl<T> core::ops::Div<InverseLuminousFlux<T>> for &i32 where T: NumLike+From<i32> {
7755	type Output = LuminousFlux<T>;
7756	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7757		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7758	}
7759}
7760/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7761impl<T> core::ops::Div<&InverseLuminousFlux<T>> for i32 where T: NumLike+From<i32> {
7762	type Output = LuminousFlux<T>;
7763	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7764		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7765	}
7766}
7767/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7768impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &i32 where T: NumLike+From<i32> {
7769	type Output = LuminousFlux<T>;
7770	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7771		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7772	}
7773}
7774
7775// 1/InverseLuminousFlux -> LuminousFlux
7776/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7777#[cfg(feature="num-bigfloat")]
7778impl<T> core::ops::Div<InverseLuminousFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7779	type Output = LuminousFlux<T>;
7780	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7781		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7782	}
7783}
7784/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7785#[cfg(feature="num-bigfloat")]
7786impl<T> core::ops::Div<InverseLuminousFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7787	type Output = LuminousFlux<T>;
7788	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7789		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7790	}
7791}
7792/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7793#[cfg(feature="num-bigfloat")]
7794impl<T> core::ops::Div<&InverseLuminousFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7795	type Output = LuminousFlux<T>;
7796	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7797		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7798	}
7799}
7800/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7801#[cfg(feature="num-bigfloat")]
7802impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
7803	type Output = LuminousFlux<T>;
7804	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7805		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7806	}
7807}
7808
7809// 1/InverseLuminousFlux -> LuminousFlux
7810/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7811#[cfg(feature="num-complex")]
7812impl<T> core::ops::Div<InverseLuminousFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7813	type Output = LuminousFlux<T>;
7814	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7815		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7816	}
7817}
7818/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7819#[cfg(feature="num-complex")]
7820impl<T> core::ops::Div<InverseLuminousFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7821	type Output = LuminousFlux<T>;
7822	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7823		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7824	}
7825}
7826/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7827#[cfg(feature="num-complex")]
7828impl<T> core::ops::Div<&InverseLuminousFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7829	type Output = LuminousFlux<T>;
7830	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7831		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7832	}
7833}
7834/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7835#[cfg(feature="num-complex")]
7836impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
7837	type Output = LuminousFlux<T>;
7838	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7839		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7840	}
7841}
7842
7843// 1/InverseLuminousFlux -> LuminousFlux
7844/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7845#[cfg(feature="num-complex")]
7846impl<T> core::ops::Div<InverseLuminousFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7847	type Output = LuminousFlux<T>;
7848	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7849		LuminousFlux{lm: T::from(self) / rhs.per_lm}
7850	}
7851}
7852/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7853#[cfg(feature="num-complex")]
7854impl<T> core::ops::Div<InverseLuminousFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7855	type Output = LuminousFlux<T>;
7856	fn div(self, rhs: InverseLuminousFlux<T>) -> Self::Output {
7857		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm}
7858	}
7859}
7860/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7861#[cfg(feature="num-complex")]
7862impl<T> core::ops::Div<&InverseLuminousFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7863	type Output = LuminousFlux<T>;
7864	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7865		LuminousFlux{lm: T::from(self) / rhs.per_lm.clone()}
7866	}
7867}
7868/// Dividing a scalar value by a InverseLuminousFlux unit value returns a value of type LuminousFlux
7869#[cfg(feature="num-complex")]
7870impl<T> core::ops::Div<&InverseLuminousFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
7871	type Output = LuminousFlux<T>;
7872	fn div(self, rhs: &InverseLuminousFlux<T>) -> Self::Output {
7873		LuminousFlux{lm: T::from(self.clone()) / rhs.per_lm.clone()}
7874	}
7875}
7876
7877/// The inverse of magnetic flux unit type, defined as inverse webers in SI units
7878#[derive(UnitStruct, Debug, Clone)]
7879#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
7880pub struct InverseMagneticFlux<T: NumLike>{
7881	/// The value of this Inverse magnetic flux in inverse webers
7882	pub per_Wb: T
7883}
7884
7885impl<T> InverseMagneticFlux<T> where T: NumLike {
7886
7887	/// Returns the standard unit name of inverse magnetic flux: "inverse webers"
7888	pub fn unit_name() -> &'static str { "inverse webers" }
7889	
7890	/// Returns the abbreviated name or symbol of inverse magnetic flux: "1/Wb" for inverse webers
7891	pub fn unit_symbol() -> &'static str { "1/Wb" }
7892	
7893	/// Returns a new inverse magnetic flux value from the given number of inverse webers
7894	///
7895	/// # Arguments
7896	/// * `per_Wb` - Any number-like type, representing a quantity of inverse webers
7897	pub fn from_per_Wb(per_Wb: T) -> Self { InverseMagneticFlux{per_Wb: per_Wb} }
7898	
7899	/// Returns a copy of this inverse magnetic flux value in inverse webers
7900	pub fn to_per_Wb(&self) -> T { self.per_Wb.clone() }
7901
7902	/// Returns a new inverse magnetic flux value from the given number of inverse webers
7903	///
7904	/// # Arguments
7905	/// * `per_weber` - Any number-like type, representing a quantity of inverse webers
7906	pub fn from_per_weber(per_weber: T) -> Self { InverseMagneticFlux{per_Wb: per_weber} }
7907	
7908	/// Returns a copy of this inverse magnetic flux value in inverse webers
7909	pub fn to_per_weber(&self) -> T { self.per_Wb.clone() }
7910
7911}
7912
7913impl<T> fmt::Display for InverseMagneticFlux<T> where T: NumLike {
7914	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7915		write!(f, "{} {}", &self.per_Wb, Self::unit_symbol())
7916	}
7917}
7918
7919impl<T> InverseMagneticFlux<T> where T: NumLike+From<f64> {
7920	
7921	/// Returns a copy of this inverse magnetic flux value in inverse milliwebers
7922	/// 
7923	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7924	pub fn to_per_mWb(&self) -> T {
7925		return self.per_Wb.clone() * T::from(0.001_f64);
7926	}
7927
7928	/// Returns a new inverse magnetic flux value from the given number of inverse milliwebers
7929	/// 
7930	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7931	///
7932	/// # Arguments
7933	/// * `per_mWb` - Any number-like type, representing a quantity of inverse milliwebers
7934	pub fn from_per_mWb(per_mWb: T) -> Self {
7935		InverseMagneticFlux{per_Wb: per_mWb * T::from(1000.0_f64)}
7936	}
7937
7938	/// Returns a copy of this inverse magnetic flux value in inverse microwebers
7939	/// 
7940	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7941	pub fn to_per_uWb(&self) -> T {
7942		return self.per_Wb.clone() * T::from(1e-06_f64);
7943	}
7944
7945	/// Returns a new inverse magnetic flux value from the given number of inverse microwebers
7946	/// 
7947	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7948	///
7949	/// # Arguments
7950	/// * `per_uWb` - Any number-like type, representing a quantity of inverse microwebers
7951	pub fn from_per_uWb(per_uWb: T) -> Self {
7952		InverseMagneticFlux{per_Wb: per_uWb * T::from(1000000.0_f64)}
7953	}
7954
7955	/// Returns a copy of this inverse magnetic flux value in inverse nanowebers
7956	/// 
7957	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7958	pub fn to_per_nWb(&self) -> T {
7959		return self.per_Wb.clone() * T::from(1e-09_f64);
7960	}
7961
7962	/// Returns a new inverse magnetic flux value from the given number of inverse nanowebers
7963	/// 
7964	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7965	///
7966	/// # Arguments
7967	/// * `per_nWb` - Any number-like type, representing a quantity of inverse nanowebers
7968	pub fn from_per_nWb(per_nWb: T) -> Self {
7969		InverseMagneticFlux{per_Wb: per_nWb * T::from(1000000000.0_f64)}
7970	}
7971
7972	/// Returns a copy of this inverse magnetic flux value in inverse kilowebers
7973	/// 
7974	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7975	pub fn to_per_kWb(&self) -> T {
7976		return self.per_Wb.clone() * T::from(1000.0_f64);
7977	}
7978
7979	/// Returns a new inverse magnetic flux value from the given number of inverse kilowebers
7980	/// 
7981	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7982	///
7983	/// # Arguments
7984	/// * `per_kWb` - Any number-like type, representing a quantity of inverse kilowebers
7985	pub fn from_per_kWb(per_kWb: T) -> Self {
7986		InverseMagneticFlux{per_Wb: per_kWb * T::from(0.001_f64)}
7987	}
7988
7989	/// Returns a copy of this inverse magnetic flux value in inverse megawebers
7990	/// 
7991	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7992	pub fn to_per_MWb(&self) -> T {
7993		return self.per_Wb.clone() * T::from(1000000.0_f64);
7994	}
7995
7996	/// Returns a new inverse magnetic flux value from the given number of inverse megawebers
7997	/// 
7998	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
7999	///
8000	/// # Arguments
8001	/// * `per_MWb` - Any number-like type, representing a quantity of inverse megawebers
8002	pub fn from_per_MWb(per_MWb: T) -> Self {
8003		InverseMagneticFlux{per_Wb: per_MWb * T::from(1e-06_f64)}
8004	}
8005
8006	/// Returns a copy of this inverse magnetic flux value in inverse gigawebers
8007	/// 
8008	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
8009	pub fn to_per_GWb(&self) -> T {
8010		return self.per_Wb.clone() * T::from(1000000000.0_f64);
8011	}
8012
8013	/// Returns a new inverse magnetic flux value from the given number of inverse gigawebers
8014	/// 
8015	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
8016	///
8017	/// # Arguments
8018	/// * `per_GWb` - Any number-like type, representing a quantity of inverse gigawebers
8019	pub fn from_per_GWb(per_GWb: T) -> Self {
8020		InverseMagneticFlux{per_Wb: per_GWb * T::from(1e-09_f64)}
8021	}
8022
8023}
8024
8025
8026/// Multiplying a unit value by a scalar value returns a unit value
8027#[cfg(feature="num-bigfloat")]
8028impl core::ops::Mul<InverseMagneticFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
8029	type Output = InverseMagneticFlux<num_bigfloat::BigFloat>;
8030	fn mul(self, rhs: InverseMagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
8031		InverseMagneticFlux{per_Wb: self * rhs.per_Wb}
8032	}
8033}
8034/// Multiplying a unit value by a scalar value returns a unit value
8035#[cfg(feature="num-bigfloat")]
8036impl core::ops::Mul<InverseMagneticFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
8037	type Output = InverseMagneticFlux<num_bigfloat::BigFloat>;
8038	fn mul(self, rhs: InverseMagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
8039		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb}
8040	}
8041}
8042/// Multiplying a unit value by a scalar value returns a unit value
8043#[cfg(feature="num-bigfloat")]
8044impl core::ops::Mul<&InverseMagneticFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
8045	type Output = InverseMagneticFlux<num_bigfloat::BigFloat>;
8046	fn mul(self, rhs: &InverseMagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
8047		InverseMagneticFlux{per_Wb: self * rhs.per_Wb.clone()}
8048	}
8049}
8050/// Multiplying a unit value by a scalar value returns a unit value
8051#[cfg(feature="num-bigfloat")]
8052impl core::ops::Mul<&InverseMagneticFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
8053	type Output = InverseMagneticFlux<num_bigfloat::BigFloat>;
8054	fn mul(self, rhs: &InverseMagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
8055		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb.clone()}
8056	}
8057}
8058
8059/// Multiplying a unit value by a scalar value returns a unit value
8060#[cfg(feature="num-complex")]
8061impl core::ops::Mul<InverseMagneticFlux<num_complex::Complex32>> for num_complex::Complex32 {
8062	type Output = InverseMagneticFlux<num_complex::Complex32>;
8063	fn mul(self, rhs: InverseMagneticFlux<num_complex::Complex32>) -> Self::Output {
8064		InverseMagneticFlux{per_Wb: self * rhs.per_Wb}
8065	}
8066}
8067/// Multiplying a unit value by a scalar value returns a unit value
8068#[cfg(feature="num-complex")]
8069impl core::ops::Mul<InverseMagneticFlux<num_complex::Complex32>> for &num_complex::Complex32 {
8070	type Output = InverseMagneticFlux<num_complex::Complex32>;
8071	fn mul(self, rhs: InverseMagneticFlux<num_complex::Complex32>) -> Self::Output {
8072		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb}
8073	}
8074}
8075/// Multiplying a unit value by a scalar value returns a unit value
8076#[cfg(feature="num-complex")]
8077impl core::ops::Mul<&InverseMagneticFlux<num_complex::Complex32>> for num_complex::Complex32 {
8078	type Output = InverseMagneticFlux<num_complex::Complex32>;
8079	fn mul(self, rhs: &InverseMagneticFlux<num_complex::Complex32>) -> Self::Output {
8080		InverseMagneticFlux{per_Wb: self * rhs.per_Wb.clone()}
8081	}
8082}
8083/// Multiplying a unit value by a scalar value returns a unit value
8084#[cfg(feature="num-complex")]
8085impl core::ops::Mul<&InverseMagneticFlux<num_complex::Complex32>> for &num_complex::Complex32 {
8086	type Output = InverseMagneticFlux<num_complex::Complex32>;
8087	fn mul(self, rhs: &InverseMagneticFlux<num_complex::Complex32>) -> Self::Output {
8088		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb.clone()}
8089	}
8090}
8091
8092/// Multiplying a unit value by a scalar value returns a unit value
8093#[cfg(feature="num-complex")]
8094impl core::ops::Mul<InverseMagneticFlux<num_complex::Complex64>> for num_complex::Complex64 {
8095	type Output = InverseMagneticFlux<num_complex::Complex64>;
8096	fn mul(self, rhs: InverseMagneticFlux<num_complex::Complex64>) -> Self::Output {
8097		InverseMagneticFlux{per_Wb: self * rhs.per_Wb}
8098	}
8099}
8100/// Multiplying a unit value by a scalar value returns a unit value
8101#[cfg(feature="num-complex")]
8102impl core::ops::Mul<InverseMagneticFlux<num_complex::Complex64>> for &num_complex::Complex64 {
8103	type Output = InverseMagneticFlux<num_complex::Complex64>;
8104	fn mul(self, rhs: InverseMagneticFlux<num_complex::Complex64>) -> Self::Output {
8105		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb}
8106	}
8107}
8108/// Multiplying a unit value by a scalar value returns a unit value
8109#[cfg(feature="num-complex")]
8110impl core::ops::Mul<&InverseMagneticFlux<num_complex::Complex64>> for num_complex::Complex64 {
8111	type Output = InverseMagneticFlux<num_complex::Complex64>;
8112	fn mul(self, rhs: &InverseMagneticFlux<num_complex::Complex64>) -> Self::Output {
8113		InverseMagneticFlux{per_Wb: self * rhs.per_Wb.clone()}
8114	}
8115}
8116/// Multiplying a unit value by a scalar value returns a unit value
8117#[cfg(feature="num-complex")]
8118impl core::ops::Mul<&InverseMagneticFlux<num_complex::Complex64>> for &num_complex::Complex64 {
8119	type Output = InverseMagneticFlux<num_complex::Complex64>;
8120	fn mul(self, rhs: &InverseMagneticFlux<num_complex::Complex64>) -> Self::Output {
8121		InverseMagneticFlux{per_Wb: self.clone() * rhs.per_Wb.clone()}
8122	}
8123}
8124
8125
8126
8127
8128// InverseMagneticFlux * Current -> InverseInductance
8129/// Multiplying a InverseMagneticFlux by a Current returns a value of type InverseInductance
8130impl<T> core::ops::Mul<Current<T>> for InverseMagneticFlux<T> where T: NumLike {
8131	type Output = InverseInductance<T>;
8132	fn mul(self, rhs: Current<T>) -> Self::Output {
8133		InverseInductance{per_H: self.per_Wb * rhs.A}
8134	}
8135}
8136/// Multiplying a InverseMagneticFlux by a Current returns a value of type InverseInductance
8137impl<T> core::ops::Mul<Current<T>> for &InverseMagneticFlux<T> where T: NumLike {
8138	type Output = InverseInductance<T>;
8139	fn mul(self, rhs: Current<T>) -> Self::Output {
8140		InverseInductance{per_H: self.per_Wb.clone() * rhs.A}
8141	}
8142}
8143/// Multiplying a InverseMagneticFlux by a Current returns a value of type InverseInductance
8144impl<T> core::ops::Mul<&Current<T>> for InverseMagneticFlux<T> where T: NumLike {
8145	type Output = InverseInductance<T>;
8146	fn mul(self, rhs: &Current<T>) -> Self::Output {
8147		InverseInductance{per_H: self.per_Wb * rhs.A.clone()}
8148	}
8149}
8150/// Multiplying a InverseMagneticFlux by a Current returns a value of type InverseInductance
8151impl<T> core::ops::Mul<&Current<T>> for &InverseMagneticFlux<T> where T: NumLike {
8152	type Output = InverseInductance<T>;
8153	fn mul(self, rhs: &Current<T>) -> Self::Output {
8154		InverseInductance{per_H: self.per_Wb.clone() * rhs.A.clone()}
8155	}
8156}
8157
8158// InverseMagneticFlux / Current -> InverseEnergy
8159/// Dividing a InverseMagneticFlux by a Current returns a value of type InverseEnergy
8160impl<T> core::ops::Div<Current<T>> for InverseMagneticFlux<T> where T: NumLike {
8161	type Output = InverseEnergy<T>;
8162	fn div(self, rhs: Current<T>) -> Self::Output {
8163		InverseEnergy{per_J: self.per_Wb / rhs.A}
8164	}
8165}
8166/// Dividing a InverseMagneticFlux by a Current returns a value of type InverseEnergy
8167impl<T> core::ops::Div<Current<T>> for &InverseMagneticFlux<T> where T: NumLike {
8168	type Output = InverseEnergy<T>;
8169	fn div(self, rhs: Current<T>) -> Self::Output {
8170		InverseEnergy{per_J: self.per_Wb.clone() / rhs.A}
8171	}
8172}
8173/// Dividing a InverseMagneticFlux by a Current returns a value of type InverseEnergy
8174impl<T> core::ops::Div<&Current<T>> for InverseMagneticFlux<T> where T: NumLike {
8175	type Output = InverseEnergy<T>;
8176	fn div(self, rhs: &Current<T>) -> Self::Output {
8177		InverseEnergy{per_J: self.per_Wb / rhs.A.clone()}
8178	}
8179}
8180/// Dividing a InverseMagneticFlux by a Current returns a value of type InverseEnergy
8181impl<T> core::ops::Div<&Current<T>> for &InverseMagneticFlux<T> where T: NumLike {
8182	type Output = InverseEnergy<T>;
8183	fn div(self, rhs: &Current<T>) -> Self::Output {
8184		InverseEnergy{per_J: self.per_Wb.clone() / rhs.A.clone()}
8185	}
8186}
8187
8188// InverseMagneticFlux * InverseCurrent -> InverseEnergy
8189/// Multiplying a InverseMagneticFlux by a InverseCurrent returns a value of type InverseEnergy
8190impl<T> core::ops::Mul<InverseCurrent<T>> for InverseMagneticFlux<T> where T: NumLike {
8191	type Output = InverseEnergy<T>;
8192	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
8193		InverseEnergy{per_J: self.per_Wb * rhs.per_A}
8194	}
8195}
8196/// Multiplying a InverseMagneticFlux by a InverseCurrent returns a value of type InverseEnergy
8197impl<T> core::ops::Mul<InverseCurrent<T>> for &InverseMagneticFlux<T> where T: NumLike {
8198	type Output = InverseEnergy<T>;
8199	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
8200		InverseEnergy{per_J: self.per_Wb.clone() * rhs.per_A}
8201	}
8202}
8203/// Multiplying a InverseMagneticFlux by a InverseCurrent returns a value of type InverseEnergy
8204impl<T> core::ops::Mul<&InverseCurrent<T>> for InverseMagneticFlux<T> where T: NumLike {
8205	type Output = InverseEnergy<T>;
8206	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
8207		InverseEnergy{per_J: self.per_Wb * rhs.per_A.clone()}
8208	}
8209}
8210/// Multiplying a InverseMagneticFlux by a InverseCurrent returns a value of type InverseEnergy
8211impl<T> core::ops::Mul<&InverseCurrent<T>> for &InverseMagneticFlux<T> where T: NumLike {
8212	type Output = InverseEnergy<T>;
8213	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
8214		InverseEnergy{per_J: self.per_Wb.clone() * rhs.per_A.clone()}
8215	}
8216}
8217
8218// InverseMagneticFlux / InverseCurrent -> InverseInductance
8219/// Dividing a InverseMagneticFlux by a InverseCurrent returns a value of type InverseInductance
8220impl<T> core::ops::Div<InverseCurrent<T>> for InverseMagneticFlux<T> where T: NumLike {
8221	type Output = InverseInductance<T>;
8222	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
8223		InverseInductance{per_H: self.per_Wb / rhs.per_A}
8224	}
8225}
8226/// Dividing a InverseMagneticFlux by a InverseCurrent returns a value of type InverseInductance
8227impl<T> core::ops::Div<InverseCurrent<T>> for &InverseMagneticFlux<T> where T: NumLike {
8228	type Output = InverseInductance<T>;
8229	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
8230		InverseInductance{per_H: self.per_Wb.clone() / rhs.per_A}
8231	}
8232}
8233/// Dividing a InverseMagneticFlux by a InverseCurrent returns a value of type InverseInductance
8234impl<T> core::ops::Div<&InverseCurrent<T>> for InverseMagneticFlux<T> where T: NumLike {
8235	type Output = InverseInductance<T>;
8236	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
8237		InverseInductance{per_H: self.per_Wb / rhs.per_A.clone()}
8238	}
8239}
8240/// Dividing a InverseMagneticFlux by a InverseCurrent returns a value of type InverseInductance
8241impl<T> core::ops::Div<&InverseCurrent<T>> for &InverseMagneticFlux<T> where T: NumLike {
8242	type Output = InverseInductance<T>;
8243	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
8244		InverseInductance{per_H: self.per_Wb.clone() / rhs.per_A.clone()}
8245	}
8246}
8247
8248// InverseMagneticFlux * Time -> InverseVoltage
8249/// Multiplying a InverseMagneticFlux by a Time returns a value of type InverseVoltage
8250impl<T> core::ops::Mul<Time<T>> for InverseMagneticFlux<T> where T: NumLike {
8251	type Output = InverseVoltage<T>;
8252	fn mul(self, rhs: Time<T>) -> Self::Output {
8253		InverseVoltage{per_V: self.per_Wb * rhs.s}
8254	}
8255}
8256/// Multiplying a InverseMagneticFlux by a Time returns a value of type InverseVoltage
8257impl<T> core::ops::Mul<Time<T>> for &InverseMagneticFlux<T> where T: NumLike {
8258	type Output = InverseVoltage<T>;
8259	fn mul(self, rhs: Time<T>) -> Self::Output {
8260		InverseVoltage{per_V: self.per_Wb.clone() * rhs.s}
8261	}
8262}
8263/// Multiplying a InverseMagneticFlux by a Time returns a value of type InverseVoltage
8264impl<T> core::ops::Mul<&Time<T>> for InverseMagneticFlux<T> where T: NumLike {
8265	type Output = InverseVoltage<T>;
8266	fn mul(self, rhs: &Time<T>) -> Self::Output {
8267		InverseVoltage{per_V: self.per_Wb * rhs.s.clone()}
8268	}
8269}
8270/// Multiplying a InverseMagneticFlux by a Time returns a value of type InverseVoltage
8271impl<T> core::ops::Mul<&Time<T>> for &InverseMagneticFlux<T> where T: NumLike {
8272	type Output = InverseVoltage<T>;
8273	fn mul(self, rhs: &Time<T>) -> Self::Output {
8274		InverseVoltage{per_V: self.per_Wb.clone() * rhs.s.clone()}
8275	}
8276}
8277
8278// InverseMagneticFlux * Charge -> Conductance
8279/// Multiplying a InverseMagneticFlux by a Charge returns a value of type Conductance
8280impl<T> core::ops::Mul<Charge<T>> for InverseMagneticFlux<T> where T: NumLike {
8281	type Output = Conductance<T>;
8282	fn mul(self, rhs: Charge<T>) -> Self::Output {
8283		Conductance{S: self.per_Wb * rhs.C}
8284	}
8285}
8286/// Multiplying a InverseMagneticFlux by a Charge returns a value of type Conductance
8287impl<T> core::ops::Mul<Charge<T>> for &InverseMagneticFlux<T> where T: NumLike {
8288	type Output = Conductance<T>;
8289	fn mul(self, rhs: Charge<T>) -> Self::Output {
8290		Conductance{S: self.per_Wb.clone() * rhs.C}
8291	}
8292}
8293/// Multiplying a InverseMagneticFlux by a Charge returns a value of type Conductance
8294impl<T> core::ops::Mul<&Charge<T>> for InverseMagneticFlux<T> where T: NumLike {
8295	type Output = Conductance<T>;
8296	fn mul(self, rhs: &Charge<T>) -> Self::Output {
8297		Conductance{S: self.per_Wb * rhs.C.clone()}
8298	}
8299}
8300/// Multiplying a InverseMagneticFlux by a Charge returns a value of type Conductance
8301impl<T> core::ops::Mul<&Charge<T>> for &InverseMagneticFlux<T> where T: NumLike {
8302	type Output = Conductance<T>;
8303	fn mul(self, rhs: &Charge<T>) -> Self::Output {
8304		Conductance{S: self.per_Wb.clone() * rhs.C.clone()}
8305	}
8306}
8307
8308// InverseMagneticFlux / Conductance -> InverseCharge
8309/// Dividing a InverseMagneticFlux by a Conductance returns a value of type InverseCharge
8310impl<T> core::ops::Div<Conductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8311	type Output = InverseCharge<T>;
8312	fn div(self, rhs: Conductance<T>) -> Self::Output {
8313		InverseCharge{per_C: self.per_Wb / rhs.S}
8314	}
8315}
8316/// Dividing a InverseMagneticFlux by a Conductance returns a value of type InverseCharge
8317impl<T> core::ops::Div<Conductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8318	type Output = InverseCharge<T>;
8319	fn div(self, rhs: Conductance<T>) -> Self::Output {
8320		InverseCharge{per_C: self.per_Wb.clone() / rhs.S}
8321	}
8322}
8323/// Dividing a InverseMagneticFlux by a Conductance returns a value of type InverseCharge
8324impl<T> core::ops::Div<&Conductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8325	type Output = InverseCharge<T>;
8326	fn div(self, rhs: &Conductance<T>) -> Self::Output {
8327		InverseCharge{per_C: self.per_Wb / rhs.S.clone()}
8328	}
8329}
8330/// Dividing a InverseMagneticFlux by a Conductance returns a value of type InverseCharge
8331impl<T> core::ops::Div<&Conductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8332	type Output = InverseCharge<T>;
8333	fn div(self, rhs: &Conductance<T>) -> Self::Output {
8334		InverseCharge{per_C: self.per_Wb.clone() / rhs.S.clone()}
8335	}
8336}
8337
8338// InverseMagneticFlux * Inductance -> InverseCurrent
8339/// Multiplying a InverseMagneticFlux by a Inductance returns a value of type InverseCurrent
8340impl<T> core::ops::Mul<Inductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8341	type Output = InverseCurrent<T>;
8342	fn mul(self, rhs: Inductance<T>) -> Self::Output {
8343		InverseCurrent{per_A: self.per_Wb * rhs.H}
8344	}
8345}
8346/// Multiplying a InverseMagneticFlux by a Inductance returns a value of type InverseCurrent
8347impl<T> core::ops::Mul<Inductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8348	type Output = InverseCurrent<T>;
8349	fn mul(self, rhs: Inductance<T>) -> Self::Output {
8350		InverseCurrent{per_A: self.per_Wb.clone() * rhs.H}
8351	}
8352}
8353/// Multiplying a InverseMagneticFlux by a Inductance returns a value of type InverseCurrent
8354impl<T> core::ops::Mul<&Inductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8355	type Output = InverseCurrent<T>;
8356	fn mul(self, rhs: &Inductance<T>) -> Self::Output {
8357		InverseCurrent{per_A: self.per_Wb * rhs.H.clone()}
8358	}
8359}
8360/// Multiplying a InverseMagneticFlux by a Inductance returns a value of type InverseCurrent
8361impl<T> core::ops::Mul<&Inductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8362	type Output = InverseCurrent<T>;
8363	fn mul(self, rhs: &Inductance<T>) -> Self::Output {
8364		InverseCurrent{per_A: self.per_Wb.clone() * rhs.H.clone()}
8365	}
8366}
8367
8368// InverseMagneticFlux / InverseCharge -> Conductance
8369/// Dividing a InverseMagneticFlux by a InverseCharge returns a value of type Conductance
8370impl<T> core::ops::Div<InverseCharge<T>> for InverseMagneticFlux<T> where T: NumLike {
8371	type Output = Conductance<T>;
8372	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
8373		Conductance{S: self.per_Wb / rhs.per_C}
8374	}
8375}
8376/// Dividing a InverseMagneticFlux by a InverseCharge returns a value of type Conductance
8377impl<T> core::ops::Div<InverseCharge<T>> for &InverseMagneticFlux<T> where T: NumLike {
8378	type Output = Conductance<T>;
8379	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
8380		Conductance{S: self.per_Wb.clone() / rhs.per_C}
8381	}
8382}
8383/// Dividing a InverseMagneticFlux by a InverseCharge returns a value of type Conductance
8384impl<T> core::ops::Div<&InverseCharge<T>> for InverseMagneticFlux<T> where T: NumLike {
8385	type Output = Conductance<T>;
8386	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
8387		Conductance{S: self.per_Wb / rhs.per_C.clone()}
8388	}
8389}
8390/// Dividing a InverseMagneticFlux by a InverseCharge returns a value of type Conductance
8391impl<T> core::ops::Div<&InverseCharge<T>> for &InverseMagneticFlux<T> where T: NumLike {
8392	type Output = Conductance<T>;
8393	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
8394		Conductance{S: self.per_Wb.clone() / rhs.per_C.clone()}
8395	}
8396}
8397
8398// InverseMagneticFlux / InverseInductance -> InverseCurrent
8399/// Dividing a InverseMagneticFlux by a InverseInductance returns a value of type InverseCurrent
8400impl<T> core::ops::Div<InverseInductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8401	type Output = InverseCurrent<T>;
8402	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
8403		InverseCurrent{per_A: self.per_Wb / rhs.per_H}
8404	}
8405}
8406/// Dividing a InverseMagneticFlux by a InverseInductance returns a value of type InverseCurrent
8407impl<T> core::ops::Div<InverseInductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8408	type Output = InverseCurrent<T>;
8409	fn div(self, rhs: InverseInductance<T>) -> Self::Output {
8410		InverseCurrent{per_A: self.per_Wb.clone() / rhs.per_H}
8411	}
8412}
8413/// Dividing a InverseMagneticFlux by a InverseInductance returns a value of type InverseCurrent
8414impl<T> core::ops::Div<&InverseInductance<T>> for InverseMagneticFlux<T> where T: NumLike {
8415	type Output = InverseCurrent<T>;
8416	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
8417		InverseCurrent{per_A: self.per_Wb / rhs.per_H.clone()}
8418	}
8419}
8420/// Dividing a InverseMagneticFlux by a InverseInductance returns a value of type InverseCurrent
8421impl<T> core::ops::Div<&InverseInductance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8422	type Output = InverseCurrent<T>;
8423	fn div(self, rhs: &InverseInductance<T>) -> Self::Output {
8424		InverseCurrent{per_A: self.per_Wb.clone() / rhs.per_H.clone()}
8425	}
8426}
8427
8428// InverseMagneticFlux / InverseMagneticFluxDensity -> InverseArea
8429/// Dividing a InverseMagneticFlux by a InverseMagneticFluxDensity returns a value of type InverseArea
8430impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for InverseMagneticFlux<T> where T: NumLike {
8431	type Output = InverseArea<T>;
8432	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
8433		InverseArea{per_m2: self.per_Wb / rhs.m2_per_Wb}
8434	}
8435}
8436/// Dividing a InverseMagneticFlux by a InverseMagneticFluxDensity returns a value of type InverseArea
8437impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &InverseMagneticFlux<T> where T: NumLike {
8438	type Output = InverseArea<T>;
8439	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
8440		InverseArea{per_m2: self.per_Wb.clone() / rhs.m2_per_Wb}
8441	}
8442}
8443/// Dividing a InverseMagneticFlux by a InverseMagneticFluxDensity returns a value of type InverseArea
8444impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for InverseMagneticFlux<T> where T: NumLike {
8445	type Output = InverseArea<T>;
8446	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
8447		InverseArea{per_m2: self.per_Wb / rhs.m2_per_Wb.clone()}
8448	}
8449}
8450/// Dividing a InverseMagneticFlux by a InverseMagneticFluxDensity returns a value of type InverseArea
8451impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &InverseMagneticFlux<T> where T: NumLike {
8452	type Output = InverseArea<T>;
8453	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
8454		InverseArea{per_m2: self.per_Wb.clone() / rhs.m2_per_Wb.clone()}
8455	}
8456}
8457
8458// InverseMagneticFlux / InverseVoltage -> Frequency
8459/// Dividing a InverseMagneticFlux by a InverseVoltage returns a value of type Frequency
8460impl<T> core::ops::Div<InverseVoltage<T>> for InverseMagneticFlux<T> where T: NumLike {
8461	type Output = Frequency<T>;
8462	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
8463		Frequency{Hz: self.per_Wb / rhs.per_V}
8464	}
8465}
8466/// Dividing a InverseMagneticFlux by a InverseVoltage returns a value of type Frequency
8467impl<T> core::ops::Div<InverseVoltage<T>> for &InverseMagneticFlux<T> where T: NumLike {
8468	type Output = Frequency<T>;
8469	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
8470		Frequency{Hz: self.per_Wb.clone() / rhs.per_V}
8471	}
8472}
8473/// Dividing a InverseMagneticFlux by a InverseVoltage returns a value of type Frequency
8474impl<T> core::ops::Div<&InverseVoltage<T>> for InverseMagneticFlux<T> where T: NumLike {
8475	type Output = Frequency<T>;
8476	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
8477		Frequency{Hz: self.per_Wb / rhs.per_V.clone()}
8478	}
8479}
8480/// Dividing a InverseMagneticFlux by a InverseVoltage returns a value of type Frequency
8481impl<T> core::ops::Div<&InverseVoltage<T>> for &InverseMagneticFlux<T> where T: NumLike {
8482	type Output = Frequency<T>;
8483	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
8484		Frequency{Hz: self.per_Wb.clone() / rhs.per_V.clone()}
8485	}
8486}
8487
8488// InverseMagneticFlux * MagneticFluxDensity -> InverseArea
8489/// Multiplying a InverseMagneticFlux by a MagneticFluxDensity returns a value of type InverseArea
8490impl<T> core::ops::Mul<MagneticFluxDensity<T>> for InverseMagneticFlux<T> where T: NumLike {
8491	type Output = InverseArea<T>;
8492	fn mul(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
8493		InverseArea{per_m2: self.per_Wb * rhs.T}
8494	}
8495}
8496/// Multiplying a InverseMagneticFlux by a MagneticFluxDensity returns a value of type InverseArea
8497impl<T> core::ops::Mul<MagneticFluxDensity<T>> for &InverseMagneticFlux<T> where T: NumLike {
8498	type Output = InverseArea<T>;
8499	fn mul(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
8500		InverseArea{per_m2: self.per_Wb.clone() * rhs.T}
8501	}
8502}
8503/// Multiplying a InverseMagneticFlux by a MagneticFluxDensity returns a value of type InverseArea
8504impl<T> core::ops::Mul<&MagneticFluxDensity<T>> for InverseMagneticFlux<T> where T: NumLike {
8505	type Output = InverseArea<T>;
8506	fn mul(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
8507		InverseArea{per_m2: self.per_Wb * rhs.T.clone()}
8508	}
8509}
8510/// Multiplying a InverseMagneticFlux by a MagneticFluxDensity returns a value of type InverseArea
8511impl<T> core::ops::Mul<&MagneticFluxDensity<T>> for &InverseMagneticFlux<T> where T: NumLike {
8512	type Output = InverseArea<T>;
8513	fn mul(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
8514		InverseArea{per_m2: self.per_Wb.clone() * rhs.T.clone()}
8515	}
8516}
8517
8518// InverseMagneticFlux * Resistance -> InverseCharge
8519/// Multiplying a InverseMagneticFlux by a Resistance returns a value of type InverseCharge
8520impl<T> core::ops::Mul<Resistance<T>> for InverseMagneticFlux<T> where T: NumLike {
8521	type Output = InverseCharge<T>;
8522	fn mul(self, rhs: Resistance<T>) -> Self::Output {
8523		InverseCharge{per_C: self.per_Wb * rhs.Ohm}
8524	}
8525}
8526/// Multiplying a InverseMagneticFlux by a Resistance returns a value of type InverseCharge
8527impl<T> core::ops::Mul<Resistance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8528	type Output = InverseCharge<T>;
8529	fn mul(self, rhs: Resistance<T>) -> Self::Output {
8530		InverseCharge{per_C: self.per_Wb.clone() * rhs.Ohm}
8531	}
8532}
8533/// Multiplying a InverseMagneticFlux by a Resistance returns a value of type InverseCharge
8534impl<T> core::ops::Mul<&Resistance<T>> for InverseMagneticFlux<T> where T: NumLike {
8535	type Output = InverseCharge<T>;
8536	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
8537		InverseCharge{per_C: self.per_Wb * rhs.Ohm.clone()}
8538	}
8539}
8540/// Multiplying a InverseMagneticFlux by a Resistance returns a value of type InverseCharge
8541impl<T> core::ops::Mul<&Resistance<T>> for &InverseMagneticFlux<T> where T: NumLike {
8542	type Output = InverseCharge<T>;
8543	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
8544		InverseCharge{per_C: self.per_Wb.clone() * rhs.Ohm.clone()}
8545	}
8546}
8547
8548// InverseMagneticFlux * Voltage -> Frequency
8549/// Multiplying a InverseMagneticFlux by a Voltage returns a value of type Frequency
8550impl<T> core::ops::Mul<Voltage<T>> for InverseMagneticFlux<T> where T: NumLike {
8551	type Output = Frequency<T>;
8552	fn mul(self, rhs: Voltage<T>) -> Self::Output {
8553		Frequency{Hz: self.per_Wb * rhs.V}
8554	}
8555}
8556/// Multiplying a InverseMagneticFlux by a Voltage returns a value of type Frequency
8557impl<T> core::ops::Mul<Voltage<T>> for &InverseMagneticFlux<T> where T: NumLike {
8558	type Output = Frequency<T>;
8559	fn mul(self, rhs: Voltage<T>) -> Self::Output {
8560		Frequency{Hz: self.per_Wb.clone() * rhs.V}
8561	}
8562}
8563/// Multiplying a InverseMagneticFlux by a Voltage returns a value of type Frequency
8564impl<T> core::ops::Mul<&Voltage<T>> for InverseMagneticFlux<T> where T: NumLike {
8565	type Output = Frequency<T>;
8566	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
8567		Frequency{Hz: self.per_Wb * rhs.V.clone()}
8568	}
8569}
8570/// Multiplying a InverseMagneticFlux by a Voltage returns a value of type Frequency
8571impl<T> core::ops::Mul<&Voltage<T>> for &InverseMagneticFlux<T> where T: NumLike {
8572	type Output = Frequency<T>;
8573	fn mul(self, rhs: &Voltage<T>) -> Self::Output {
8574		Frequency{Hz: self.per_Wb.clone() * rhs.V.clone()}
8575	}
8576}
8577
8578// InverseMagneticFlux * Area -> InverseMagneticFluxDensity
8579/// Multiplying a InverseMagneticFlux by a Area returns a value of type InverseMagneticFluxDensity
8580impl<T> core::ops::Mul<Area<T>> for InverseMagneticFlux<T> where T: NumLike {
8581	type Output = InverseMagneticFluxDensity<T>;
8582	fn mul(self, rhs: Area<T>) -> Self::Output {
8583		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb * rhs.m2}
8584	}
8585}
8586/// Multiplying a InverseMagneticFlux by a Area returns a value of type InverseMagneticFluxDensity
8587impl<T> core::ops::Mul<Area<T>> for &InverseMagneticFlux<T> where T: NumLike {
8588	type Output = InverseMagneticFluxDensity<T>;
8589	fn mul(self, rhs: Area<T>) -> Self::Output {
8590		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb.clone() * rhs.m2}
8591	}
8592}
8593/// Multiplying a InverseMagneticFlux by a Area returns a value of type InverseMagneticFluxDensity
8594impl<T> core::ops::Mul<&Area<T>> for InverseMagneticFlux<T> where T: NumLike {
8595	type Output = InverseMagneticFluxDensity<T>;
8596	fn mul(self, rhs: &Area<T>) -> Self::Output {
8597		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb * rhs.m2.clone()}
8598	}
8599}
8600/// Multiplying a InverseMagneticFlux by a Area returns a value of type InverseMagneticFluxDensity
8601impl<T> core::ops::Mul<&Area<T>> for &InverseMagneticFlux<T> where T: NumLike {
8602	type Output = InverseMagneticFluxDensity<T>;
8603	fn mul(self, rhs: &Area<T>) -> Self::Output {
8604		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb.clone() * rhs.m2.clone()}
8605	}
8606}
8607
8608// InverseMagneticFlux / InverseArea -> InverseMagneticFluxDensity
8609/// Dividing a InverseMagneticFlux by a InverseArea returns a value of type InverseMagneticFluxDensity
8610impl<T> core::ops::Div<InverseArea<T>> for InverseMagneticFlux<T> where T: NumLike {
8611	type Output = InverseMagneticFluxDensity<T>;
8612	fn div(self, rhs: InverseArea<T>) -> Self::Output {
8613		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb / rhs.per_m2}
8614	}
8615}
8616/// Dividing a InverseMagneticFlux by a InverseArea returns a value of type InverseMagneticFluxDensity
8617impl<T> core::ops::Div<InverseArea<T>> for &InverseMagneticFlux<T> where T: NumLike {
8618	type Output = InverseMagneticFluxDensity<T>;
8619	fn div(self, rhs: InverseArea<T>) -> Self::Output {
8620		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb.clone() / rhs.per_m2}
8621	}
8622}
8623/// Dividing a InverseMagneticFlux by a InverseArea returns a value of type InverseMagneticFluxDensity
8624impl<T> core::ops::Div<&InverseArea<T>> for InverseMagneticFlux<T> where T: NumLike {
8625	type Output = InverseMagneticFluxDensity<T>;
8626	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
8627		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb / rhs.per_m2.clone()}
8628	}
8629}
8630/// Dividing a InverseMagneticFlux by a InverseArea returns a value of type InverseMagneticFluxDensity
8631impl<T> core::ops::Div<&InverseArea<T>> for &InverseMagneticFlux<T> where T: NumLike {
8632	type Output = InverseMagneticFluxDensity<T>;
8633	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
8634		InverseMagneticFluxDensity{m2_per_Wb: self.per_Wb.clone() / rhs.per_m2.clone()}
8635	}
8636}
8637
8638// InverseMagneticFlux * Energy -> Current
8639/// Multiplying a InverseMagneticFlux by a Energy returns a value of type Current
8640impl<T> core::ops::Mul<Energy<T>> for InverseMagneticFlux<T> where T: NumLike {
8641	type Output = Current<T>;
8642	fn mul(self, rhs: Energy<T>) -> Self::Output {
8643		Current{A: self.per_Wb * rhs.J}
8644	}
8645}
8646/// Multiplying a InverseMagneticFlux by a Energy returns a value of type Current
8647impl<T> core::ops::Mul<Energy<T>> for &InverseMagneticFlux<T> where T: NumLike {
8648	type Output = Current<T>;
8649	fn mul(self, rhs: Energy<T>) -> Self::Output {
8650		Current{A: self.per_Wb.clone() * rhs.J}
8651	}
8652}
8653/// Multiplying a InverseMagneticFlux by a Energy returns a value of type Current
8654impl<T> core::ops::Mul<&Energy<T>> for InverseMagneticFlux<T> where T: NumLike {
8655	type Output = Current<T>;
8656	fn mul(self, rhs: &Energy<T>) -> Self::Output {
8657		Current{A: self.per_Wb * rhs.J.clone()}
8658	}
8659}
8660/// Multiplying a InverseMagneticFlux by a Energy returns a value of type Current
8661impl<T> core::ops::Mul<&Energy<T>> for &InverseMagneticFlux<T> where T: NumLike {
8662	type Output = Current<T>;
8663	fn mul(self, rhs: &Energy<T>) -> Self::Output {
8664		Current{A: self.per_Wb.clone() * rhs.J.clone()}
8665	}
8666}
8667
8668// InverseMagneticFlux * Torque -> Current
8669/// Multiplying a InverseMagneticFlux by a Torque returns a value of type Current
8670impl<T> core::ops::Mul<Torque<T>> for InverseMagneticFlux<T> where T: NumLike {
8671	type Output = Current<T>;
8672	fn mul(self, rhs: Torque<T>) -> Self::Output {
8673		Current{A: self.per_Wb * rhs.Nm}
8674	}
8675}
8676/// Multiplying a InverseMagneticFlux by a Torque returns a value of type Current
8677impl<T> core::ops::Mul<Torque<T>> for &InverseMagneticFlux<T> where T: NumLike {
8678	type Output = Current<T>;
8679	fn mul(self, rhs: Torque<T>) -> Self::Output {
8680		Current{A: self.per_Wb.clone() * rhs.Nm}
8681	}
8682}
8683/// Multiplying a InverseMagneticFlux by a Torque returns a value of type Current
8684impl<T> core::ops::Mul<&Torque<T>> for InverseMagneticFlux<T> where T: NumLike {
8685	type Output = Current<T>;
8686	fn mul(self, rhs: &Torque<T>) -> Self::Output {
8687		Current{A: self.per_Wb * rhs.Nm.clone()}
8688	}
8689}
8690/// Multiplying a InverseMagneticFlux by a Torque returns a value of type Current
8691impl<T> core::ops::Mul<&Torque<T>> for &InverseMagneticFlux<T> where T: NumLike {
8692	type Output = Current<T>;
8693	fn mul(self, rhs: &Torque<T>) -> Self::Output {
8694		Current{A: self.per_Wb.clone() * rhs.Nm.clone()}
8695	}
8696}
8697
8698// InverseMagneticFlux / Frequency -> InverseVoltage
8699/// Dividing a InverseMagneticFlux by a Frequency returns a value of type InverseVoltage
8700impl<T> core::ops::Div<Frequency<T>> for InverseMagneticFlux<T> where T: NumLike {
8701	type Output = InverseVoltage<T>;
8702	fn div(self, rhs: Frequency<T>) -> Self::Output {
8703		InverseVoltage{per_V: self.per_Wb / rhs.Hz}
8704	}
8705}
8706/// Dividing a InverseMagneticFlux by a Frequency returns a value of type InverseVoltage
8707impl<T> core::ops::Div<Frequency<T>> for &InverseMagneticFlux<T> where T: NumLike {
8708	type Output = InverseVoltage<T>;
8709	fn div(self, rhs: Frequency<T>) -> Self::Output {
8710		InverseVoltage{per_V: self.per_Wb.clone() / rhs.Hz}
8711	}
8712}
8713/// Dividing a InverseMagneticFlux by a Frequency returns a value of type InverseVoltage
8714impl<T> core::ops::Div<&Frequency<T>> for InverseMagneticFlux<T> where T: NumLike {
8715	type Output = InverseVoltage<T>;
8716	fn div(self, rhs: &Frequency<T>) -> Self::Output {
8717		InverseVoltage{per_V: self.per_Wb / rhs.Hz.clone()}
8718	}
8719}
8720/// Dividing a InverseMagneticFlux by a Frequency returns a value of type InverseVoltage
8721impl<T> core::ops::Div<&Frequency<T>> for &InverseMagneticFlux<T> where T: NumLike {
8722	type Output = InverseVoltage<T>;
8723	fn div(self, rhs: &Frequency<T>) -> Self::Output {
8724		InverseVoltage{per_V: self.per_Wb.clone() / rhs.Hz.clone()}
8725	}
8726}
8727
8728// InverseMagneticFlux / InverseEnergy -> Current
8729/// Dividing a InverseMagneticFlux by a InverseEnergy returns a value of type Current
8730impl<T> core::ops::Div<InverseEnergy<T>> for InverseMagneticFlux<T> where T: NumLike {
8731	type Output = Current<T>;
8732	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
8733		Current{A: self.per_Wb / rhs.per_J}
8734	}
8735}
8736/// Dividing a InverseMagneticFlux by a InverseEnergy returns a value of type Current
8737impl<T> core::ops::Div<InverseEnergy<T>> for &InverseMagneticFlux<T> where T: NumLike {
8738	type Output = Current<T>;
8739	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
8740		Current{A: self.per_Wb.clone() / rhs.per_J}
8741	}
8742}
8743/// Dividing a InverseMagneticFlux by a InverseEnergy returns a value of type Current
8744impl<T> core::ops::Div<&InverseEnergy<T>> for InverseMagneticFlux<T> where T: NumLike {
8745	type Output = Current<T>;
8746	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
8747		Current{A: self.per_Wb / rhs.per_J.clone()}
8748	}
8749}
8750/// Dividing a InverseMagneticFlux by a InverseEnergy returns a value of type Current
8751impl<T> core::ops::Div<&InverseEnergy<T>> for &InverseMagneticFlux<T> where T: NumLike {
8752	type Output = Current<T>;
8753	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
8754		Current{A: self.per_Wb.clone() / rhs.per_J.clone()}
8755	}
8756}
8757
8758// InverseMagneticFlux / InverseTorque -> Current
8759/// Dividing a InverseMagneticFlux by a InverseTorque returns a value of type Current
8760impl<T> core::ops::Div<InverseTorque<T>> for InverseMagneticFlux<T> where T: NumLike {
8761	type Output = Current<T>;
8762	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
8763		Current{A: self.per_Wb / rhs.per_Nm}
8764	}
8765}
8766/// Dividing a InverseMagneticFlux by a InverseTorque returns a value of type Current
8767impl<T> core::ops::Div<InverseTorque<T>> for &InverseMagneticFlux<T> where T: NumLike {
8768	type Output = Current<T>;
8769	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
8770		Current{A: self.per_Wb.clone() / rhs.per_Nm}
8771	}
8772}
8773/// Dividing a InverseMagneticFlux by a InverseTorque returns a value of type Current
8774impl<T> core::ops::Div<&InverseTorque<T>> for InverseMagneticFlux<T> where T: NumLike {
8775	type Output = Current<T>;
8776	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
8777		Current{A: self.per_Wb / rhs.per_Nm.clone()}
8778	}
8779}
8780/// Dividing a InverseMagneticFlux by a InverseTorque returns a value of type Current
8781impl<T> core::ops::Div<&InverseTorque<T>> for &InverseMagneticFlux<T> where T: NumLike {
8782	type Output = Current<T>;
8783	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
8784		Current{A: self.per_Wb.clone() / rhs.per_Nm.clone()}
8785	}
8786}
8787
8788// 1/InverseMagneticFlux -> MagneticFlux
8789/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8790impl<T> core::ops::Div<InverseMagneticFlux<T>> for f64 where T: NumLike+From<f64> {
8791	type Output = MagneticFlux<T>;
8792	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8793		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8794	}
8795}
8796/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8797impl<T> core::ops::Div<InverseMagneticFlux<T>> for &f64 where T: NumLike+From<f64> {
8798	type Output = MagneticFlux<T>;
8799	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8800		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8801	}
8802}
8803/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8804impl<T> core::ops::Div<&InverseMagneticFlux<T>> for f64 where T: NumLike+From<f64> {
8805	type Output = MagneticFlux<T>;
8806	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8807		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8808	}
8809}
8810/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8811impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &f64 where T: NumLike+From<f64> {
8812	type Output = MagneticFlux<T>;
8813	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8814		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8815	}
8816}
8817
8818// 1/InverseMagneticFlux -> MagneticFlux
8819/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8820impl<T> core::ops::Div<InverseMagneticFlux<T>> for f32 where T: NumLike+From<f32> {
8821	type Output = MagneticFlux<T>;
8822	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8823		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8824	}
8825}
8826/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8827impl<T> core::ops::Div<InverseMagneticFlux<T>> for &f32 where T: NumLike+From<f32> {
8828	type Output = MagneticFlux<T>;
8829	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8830		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8831	}
8832}
8833/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8834impl<T> core::ops::Div<&InverseMagneticFlux<T>> for f32 where T: NumLike+From<f32> {
8835	type Output = MagneticFlux<T>;
8836	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8837		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8838	}
8839}
8840/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8841impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &f32 where T: NumLike+From<f32> {
8842	type Output = MagneticFlux<T>;
8843	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8844		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8845	}
8846}
8847
8848// 1/InverseMagneticFlux -> MagneticFlux
8849/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8850impl<T> core::ops::Div<InverseMagneticFlux<T>> for i64 where T: NumLike+From<i64> {
8851	type Output = MagneticFlux<T>;
8852	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8853		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8854	}
8855}
8856/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8857impl<T> core::ops::Div<InverseMagneticFlux<T>> for &i64 where T: NumLike+From<i64> {
8858	type Output = MagneticFlux<T>;
8859	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8860		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8861	}
8862}
8863/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8864impl<T> core::ops::Div<&InverseMagneticFlux<T>> for i64 where T: NumLike+From<i64> {
8865	type Output = MagneticFlux<T>;
8866	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8867		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8868	}
8869}
8870/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8871impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &i64 where T: NumLike+From<i64> {
8872	type Output = MagneticFlux<T>;
8873	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8874		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8875	}
8876}
8877
8878// 1/InverseMagneticFlux -> MagneticFlux
8879/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8880impl<T> core::ops::Div<InverseMagneticFlux<T>> for i32 where T: NumLike+From<i32> {
8881	type Output = MagneticFlux<T>;
8882	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8883		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8884	}
8885}
8886/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8887impl<T> core::ops::Div<InverseMagneticFlux<T>> for &i32 where T: NumLike+From<i32> {
8888	type Output = MagneticFlux<T>;
8889	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8890		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8891	}
8892}
8893/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8894impl<T> core::ops::Div<&InverseMagneticFlux<T>> for i32 where T: NumLike+From<i32> {
8895	type Output = MagneticFlux<T>;
8896	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8897		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8898	}
8899}
8900/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8901impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &i32 where T: NumLike+From<i32> {
8902	type Output = MagneticFlux<T>;
8903	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8904		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8905	}
8906}
8907
8908// 1/InverseMagneticFlux -> MagneticFlux
8909/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8910#[cfg(feature="num-bigfloat")]
8911impl<T> core::ops::Div<InverseMagneticFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
8912	type Output = MagneticFlux<T>;
8913	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8914		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8915	}
8916}
8917/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8918#[cfg(feature="num-bigfloat")]
8919impl<T> core::ops::Div<InverseMagneticFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
8920	type Output = MagneticFlux<T>;
8921	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8922		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8923	}
8924}
8925/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8926#[cfg(feature="num-bigfloat")]
8927impl<T> core::ops::Div<&InverseMagneticFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
8928	type Output = MagneticFlux<T>;
8929	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8930		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8931	}
8932}
8933/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8934#[cfg(feature="num-bigfloat")]
8935impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
8936	type Output = MagneticFlux<T>;
8937	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8938		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8939	}
8940}
8941
8942// 1/InverseMagneticFlux -> MagneticFlux
8943/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8944#[cfg(feature="num-complex")]
8945impl<T> core::ops::Div<InverseMagneticFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
8946	type Output = MagneticFlux<T>;
8947	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8948		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8949	}
8950}
8951/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8952#[cfg(feature="num-complex")]
8953impl<T> core::ops::Div<InverseMagneticFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
8954	type Output = MagneticFlux<T>;
8955	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8956		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8957	}
8958}
8959/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8960#[cfg(feature="num-complex")]
8961impl<T> core::ops::Div<&InverseMagneticFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
8962	type Output = MagneticFlux<T>;
8963	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8964		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8965	}
8966}
8967/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8968#[cfg(feature="num-complex")]
8969impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
8970	type Output = MagneticFlux<T>;
8971	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8972		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
8973	}
8974}
8975
8976// 1/InverseMagneticFlux -> MagneticFlux
8977/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8978#[cfg(feature="num-complex")]
8979impl<T> core::ops::Div<InverseMagneticFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
8980	type Output = MagneticFlux<T>;
8981	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8982		MagneticFlux{Wb: T::from(self) / rhs.per_Wb}
8983	}
8984}
8985/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8986#[cfg(feature="num-complex")]
8987impl<T> core::ops::Div<InverseMagneticFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
8988	type Output = MagneticFlux<T>;
8989	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
8990		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb}
8991	}
8992}
8993/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
8994#[cfg(feature="num-complex")]
8995impl<T> core::ops::Div<&InverseMagneticFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
8996	type Output = MagneticFlux<T>;
8997	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
8998		MagneticFlux{Wb: T::from(self) / rhs.per_Wb.clone()}
8999	}
9000}
9001/// Dividing a scalar value by a InverseMagneticFlux unit value returns a value of type MagneticFlux
9002#[cfg(feature="num-complex")]
9003impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
9004	type Output = MagneticFlux<T>;
9005	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
9006		MagneticFlux{Wb: T::from(self.clone()) / rhs.per_Wb.clone()}
9007	}
9008}
9009
9010/// The inverse of magnetic flux density unit type, defined as square meters per weber in SI units
9011#[derive(UnitStruct, Debug, Clone)]
9012#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
9013pub struct InverseMagneticFluxDensity<T: NumLike>{
9014	/// The value of this Inverse magnetic flux density in square meters per weber
9015	pub m2_per_Wb: T
9016}
9017
9018impl<T> InverseMagneticFluxDensity<T> where T: NumLike {
9019
9020	/// Returns the standard unit name of inverse magnetic flux density: "square meters per weber"
9021	pub fn unit_name() -> &'static str { "square meters per weber" }
9022	
9023	/// Returns the abbreviated name or symbol of inverse magnetic flux density: "m²/Wb" for square meters per weber
9024	pub fn unit_symbol() -> &'static str { "m²/Wb" }
9025	
9026	/// Returns a new inverse magnetic flux density value from the given number of square meters per weber
9027	///
9028	/// # Arguments
9029	/// * `m2_per_Wb` - Any number-like type, representing a quantity of square meters per weber
9030	pub fn from_m2_per_Wb(m2_per_Wb: T) -> Self { InverseMagneticFluxDensity{m2_per_Wb: m2_per_Wb} }
9031	
9032	/// Returns a copy of this inverse magnetic flux density value in square meters per weber
9033	pub fn to_m2_per_Wb(&self) -> T { self.m2_per_Wb.clone() }
9034
9035	/// Returns a new inverse magnetic flux density value from the given number of square meters per weber
9036	///
9037	/// # Arguments
9038	/// * `square_meters_per_weber` - Any number-like type, representing a quantity of square meters per weber
9039	pub fn from_square_meters_per_weber(square_meters_per_weber: T) -> Self { InverseMagneticFluxDensity{m2_per_Wb: square_meters_per_weber} }
9040	
9041	/// Returns a copy of this inverse magnetic flux density value in square meters per weber
9042	pub fn to_square_meters_per_weber(&self) -> T { self.m2_per_Wb.clone() }
9043
9044	/// Returns a new inverse magnetic flux density value from the given number of inverse teslas
9045	///
9046	/// # Arguments
9047	/// * `per_T` - Any number-like type, representing a quantity of square meters per weber
9048	pub fn from_per_T(per_T: T) -> Self { InverseMagneticFluxDensity{m2_per_Wb: per_T} }
9049	
9050	/// Returns a copy of this inverse magnetic flux density value in inverse teslas
9051	pub fn to_per_T(&self) -> T { self.m2_per_Wb.clone() }
9052
9053	/// Returns a new inverse magnetic flux density value from the given number of inverse teslas
9054	///
9055	/// # Arguments
9056	/// * `per_tesla` - Any number-like type, representing a quantity of square meters per weber
9057	pub fn from_per_tesla(per_tesla: T) -> Self { InverseMagneticFluxDensity{m2_per_Wb: per_tesla} }
9058	
9059	/// Returns a copy of this inverse magnetic flux density value in inverse teslas
9060	pub fn to_per_tesla(&self) -> T { self.m2_per_Wb.clone() }
9061
9062}
9063
9064impl<T> fmt::Display for InverseMagneticFluxDensity<T> where T: NumLike {
9065	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9066		write!(f, "{} {}", &self.m2_per_Wb, Self::unit_symbol())
9067	}
9068}
9069
9070impl<T> InverseMagneticFluxDensity<T> where T: NumLike+From<f64> {
9071	
9072}
9073
9074
9075/// Multiplying a unit value by a scalar value returns a unit value
9076#[cfg(feature="num-bigfloat")]
9077impl core::ops::Mul<InverseMagneticFluxDensity<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
9078	type Output = InverseMagneticFluxDensity<num_bigfloat::BigFloat>;
9079	fn mul(self, rhs: InverseMagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
9080		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb}
9081	}
9082}
9083/// Multiplying a unit value by a scalar value returns a unit value
9084#[cfg(feature="num-bigfloat")]
9085impl core::ops::Mul<InverseMagneticFluxDensity<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
9086	type Output = InverseMagneticFluxDensity<num_bigfloat::BigFloat>;
9087	fn mul(self, rhs: InverseMagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
9088		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb}
9089	}
9090}
9091/// Multiplying a unit value by a scalar value returns a unit value
9092#[cfg(feature="num-bigfloat")]
9093impl core::ops::Mul<&InverseMagneticFluxDensity<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
9094	type Output = InverseMagneticFluxDensity<num_bigfloat::BigFloat>;
9095	fn mul(self, rhs: &InverseMagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
9096		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb.clone()}
9097	}
9098}
9099/// Multiplying a unit value by a scalar value returns a unit value
9100#[cfg(feature="num-bigfloat")]
9101impl core::ops::Mul<&InverseMagneticFluxDensity<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
9102	type Output = InverseMagneticFluxDensity<num_bigfloat::BigFloat>;
9103	fn mul(self, rhs: &InverseMagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
9104		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb.clone()}
9105	}
9106}
9107
9108/// Multiplying a unit value by a scalar value returns a unit value
9109#[cfg(feature="num-complex")]
9110impl core::ops::Mul<InverseMagneticFluxDensity<num_complex::Complex32>> for num_complex::Complex32 {
9111	type Output = InverseMagneticFluxDensity<num_complex::Complex32>;
9112	fn mul(self, rhs: InverseMagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
9113		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb}
9114	}
9115}
9116/// Multiplying a unit value by a scalar value returns a unit value
9117#[cfg(feature="num-complex")]
9118impl core::ops::Mul<InverseMagneticFluxDensity<num_complex::Complex32>> for &num_complex::Complex32 {
9119	type Output = InverseMagneticFluxDensity<num_complex::Complex32>;
9120	fn mul(self, rhs: InverseMagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
9121		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb}
9122	}
9123}
9124/// Multiplying a unit value by a scalar value returns a unit value
9125#[cfg(feature="num-complex")]
9126impl core::ops::Mul<&InverseMagneticFluxDensity<num_complex::Complex32>> for num_complex::Complex32 {
9127	type Output = InverseMagneticFluxDensity<num_complex::Complex32>;
9128	fn mul(self, rhs: &InverseMagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
9129		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb.clone()}
9130	}
9131}
9132/// Multiplying a unit value by a scalar value returns a unit value
9133#[cfg(feature="num-complex")]
9134impl core::ops::Mul<&InverseMagneticFluxDensity<num_complex::Complex32>> for &num_complex::Complex32 {
9135	type Output = InverseMagneticFluxDensity<num_complex::Complex32>;
9136	fn mul(self, rhs: &InverseMagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
9137		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb.clone()}
9138	}
9139}
9140
9141/// Multiplying a unit value by a scalar value returns a unit value
9142#[cfg(feature="num-complex")]
9143impl core::ops::Mul<InverseMagneticFluxDensity<num_complex::Complex64>> for num_complex::Complex64 {
9144	type Output = InverseMagneticFluxDensity<num_complex::Complex64>;
9145	fn mul(self, rhs: InverseMagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
9146		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb}
9147	}
9148}
9149/// Multiplying a unit value by a scalar value returns a unit value
9150#[cfg(feature="num-complex")]
9151impl core::ops::Mul<InverseMagneticFluxDensity<num_complex::Complex64>> for &num_complex::Complex64 {
9152	type Output = InverseMagneticFluxDensity<num_complex::Complex64>;
9153	fn mul(self, rhs: InverseMagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
9154		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb}
9155	}
9156}
9157/// Multiplying a unit value by a scalar value returns a unit value
9158#[cfg(feature="num-complex")]
9159impl core::ops::Mul<&InverseMagneticFluxDensity<num_complex::Complex64>> for num_complex::Complex64 {
9160	type Output = InverseMagneticFluxDensity<num_complex::Complex64>;
9161	fn mul(self, rhs: &InverseMagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
9162		InverseMagneticFluxDensity{m2_per_Wb: self * rhs.m2_per_Wb.clone()}
9163	}
9164}
9165/// Multiplying a unit value by a scalar value returns a unit value
9166#[cfg(feature="num-complex")]
9167impl core::ops::Mul<&InverseMagneticFluxDensity<num_complex::Complex64>> for &num_complex::Complex64 {
9168	type Output = InverseMagneticFluxDensity<num_complex::Complex64>;
9169	fn mul(self, rhs: &InverseMagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
9170		InverseMagneticFluxDensity{m2_per_Wb: self.clone() * rhs.m2_per_Wb.clone()}
9171	}
9172}
9173
9174
9175
9176
9177// InverseMagneticFluxDensity / InverseMagneticFlux -> Area
9178/// Dividing a InverseMagneticFluxDensity by a InverseMagneticFlux returns a value of type Area
9179impl<T> core::ops::Div<InverseMagneticFlux<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9180	type Output = Area<T>;
9181	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
9182		Area{m2: self.m2_per_Wb / rhs.per_Wb}
9183	}
9184}
9185/// Dividing a InverseMagneticFluxDensity by a InverseMagneticFlux returns a value of type Area
9186impl<T> core::ops::Div<InverseMagneticFlux<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9187	type Output = Area<T>;
9188	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
9189		Area{m2: self.m2_per_Wb.clone() / rhs.per_Wb}
9190	}
9191}
9192/// Dividing a InverseMagneticFluxDensity by a InverseMagneticFlux returns a value of type Area
9193impl<T> core::ops::Div<&InverseMagneticFlux<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9194	type Output = Area<T>;
9195	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
9196		Area{m2: self.m2_per_Wb / rhs.per_Wb.clone()}
9197	}
9198}
9199/// Dividing a InverseMagneticFluxDensity by a InverseMagneticFlux returns a value of type Area
9200impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9201	type Output = Area<T>;
9202	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
9203		Area{m2: self.m2_per_Wb.clone() / rhs.per_Wb.clone()}
9204	}
9205}
9206
9207// InverseMagneticFluxDensity * MagneticFlux -> Area
9208/// Multiplying a InverseMagneticFluxDensity by a MagneticFlux returns a value of type Area
9209impl<T> core::ops::Mul<MagneticFlux<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9210	type Output = Area<T>;
9211	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
9212		Area{m2: self.m2_per_Wb * rhs.Wb}
9213	}
9214}
9215/// Multiplying a InverseMagneticFluxDensity by a MagneticFlux returns a value of type Area
9216impl<T> core::ops::Mul<MagneticFlux<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9217	type Output = Area<T>;
9218	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
9219		Area{m2: self.m2_per_Wb.clone() * rhs.Wb}
9220	}
9221}
9222/// Multiplying a InverseMagneticFluxDensity by a MagneticFlux returns a value of type Area
9223impl<T> core::ops::Mul<&MagneticFlux<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9224	type Output = Area<T>;
9225	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
9226		Area{m2: self.m2_per_Wb * rhs.Wb.clone()}
9227	}
9228}
9229/// Multiplying a InverseMagneticFluxDensity by a MagneticFlux returns a value of type Area
9230impl<T> core::ops::Mul<&MagneticFlux<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9231	type Output = Area<T>;
9232	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
9233		Area{m2: self.m2_per_Wb.clone() * rhs.Wb.clone()}
9234	}
9235}
9236
9237// InverseMagneticFluxDensity / Area -> InverseMagneticFlux
9238/// Dividing a InverseMagneticFluxDensity by a Area returns a value of type InverseMagneticFlux
9239impl<T> core::ops::Div<Area<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9240	type Output = InverseMagneticFlux<T>;
9241	fn div(self, rhs: Area<T>) -> Self::Output {
9242		InverseMagneticFlux{per_Wb: self.m2_per_Wb / rhs.m2}
9243	}
9244}
9245/// Dividing a InverseMagneticFluxDensity by a Area returns a value of type InverseMagneticFlux
9246impl<T> core::ops::Div<Area<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9247	type Output = InverseMagneticFlux<T>;
9248	fn div(self, rhs: Area<T>) -> Self::Output {
9249		InverseMagneticFlux{per_Wb: self.m2_per_Wb.clone() / rhs.m2}
9250	}
9251}
9252/// Dividing a InverseMagneticFluxDensity by a Area returns a value of type InverseMagneticFlux
9253impl<T> core::ops::Div<&Area<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9254	type Output = InverseMagneticFlux<T>;
9255	fn div(self, rhs: &Area<T>) -> Self::Output {
9256		InverseMagneticFlux{per_Wb: self.m2_per_Wb / rhs.m2.clone()}
9257	}
9258}
9259/// Dividing a InverseMagneticFluxDensity by a Area returns a value of type InverseMagneticFlux
9260impl<T> core::ops::Div<&Area<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9261	type Output = InverseMagneticFlux<T>;
9262	fn div(self, rhs: &Area<T>) -> Self::Output {
9263		InverseMagneticFlux{per_Wb: self.m2_per_Wb.clone() / rhs.m2.clone()}
9264	}
9265}
9266
9267// InverseMagneticFluxDensity * InverseArea -> InverseMagneticFlux
9268/// Multiplying a InverseMagneticFluxDensity by a InverseArea returns a value of type InverseMagneticFlux
9269impl<T> core::ops::Mul<InverseArea<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9270	type Output = InverseMagneticFlux<T>;
9271	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
9272		InverseMagneticFlux{per_Wb: self.m2_per_Wb * rhs.per_m2}
9273	}
9274}
9275/// Multiplying a InverseMagneticFluxDensity by a InverseArea returns a value of type InverseMagneticFlux
9276impl<T> core::ops::Mul<InverseArea<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9277	type Output = InverseMagneticFlux<T>;
9278	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
9279		InverseMagneticFlux{per_Wb: self.m2_per_Wb.clone() * rhs.per_m2}
9280	}
9281}
9282/// Multiplying a InverseMagneticFluxDensity by a InverseArea returns a value of type InverseMagneticFlux
9283impl<T> core::ops::Mul<&InverseArea<T>> for InverseMagneticFluxDensity<T> where T: NumLike {
9284	type Output = InverseMagneticFlux<T>;
9285	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
9286		InverseMagneticFlux{per_Wb: self.m2_per_Wb * rhs.per_m2.clone()}
9287	}
9288}
9289/// Multiplying a InverseMagneticFluxDensity by a InverseArea returns a value of type InverseMagneticFlux
9290impl<T> core::ops::Mul<&InverseArea<T>> for &InverseMagneticFluxDensity<T> where T: NumLike {
9291	type Output = InverseMagneticFlux<T>;
9292	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
9293		InverseMagneticFlux{per_Wb: self.m2_per_Wb.clone() * rhs.per_m2.clone()}
9294	}
9295}
9296
9297// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9298/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9299impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for f64 where T: NumLike+From<f64> {
9300	type Output = MagneticFluxDensity<T>;
9301	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9302		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9303	}
9304}
9305/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9306impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &f64 where T: NumLike+From<f64> {
9307	type Output = MagneticFluxDensity<T>;
9308	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9309		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9310	}
9311}
9312/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9313impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for f64 where T: NumLike+From<f64> {
9314	type Output = MagneticFluxDensity<T>;
9315	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9316		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9317	}
9318}
9319/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9320impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &f64 where T: NumLike+From<f64> {
9321	type Output = MagneticFluxDensity<T>;
9322	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9323		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9324	}
9325}
9326
9327// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9328/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9329impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for f32 where T: NumLike+From<f32> {
9330	type Output = MagneticFluxDensity<T>;
9331	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9332		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9333	}
9334}
9335/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9336impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &f32 where T: NumLike+From<f32> {
9337	type Output = MagneticFluxDensity<T>;
9338	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9339		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9340	}
9341}
9342/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9343impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for f32 where T: NumLike+From<f32> {
9344	type Output = MagneticFluxDensity<T>;
9345	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9346		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9347	}
9348}
9349/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9350impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &f32 where T: NumLike+From<f32> {
9351	type Output = MagneticFluxDensity<T>;
9352	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9353		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9354	}
9355}
9356
9357// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9358/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9359impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for i64 where T: NumLike+From<i64> {
9360	type Output = MagneticFluxDensity<T>;
9361	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9362		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9363	}
9364}
9365/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9366impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &i64 where T: NumLike+From<i64> {
9367	type Output = MagneticFluxDensity<T>;
9368	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9369		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9370	}
9371}
9372/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9373impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for i64 where T: NumLike+From<i64> {
9374	type Output = MagneticFluxDensity<T>;
9375	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9376		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9377	}
9378}
9379/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9380impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &i64 where T: NumLike+From<i64> {
9381	type Output = MagneticFluxDensity<T>;
9382	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9383		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9384	}
9385}
9386
9387// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9388/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9389impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for i32 where T: NumLike+From<i32> {
9390	type Output = MagneticFluxDensity<T>;
9391	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9392		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9393	}
9394}
9395/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9396impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &i32 where T: NumLike+From<i32> {
9397	type Output = MagneticFluxDensity<T>;
9398	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9399		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9400	}
9401}
9402/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9403impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for i32 where T: NumLike+From<i32> {
9404	type Output = MagneticFluxDensity<T>;
9405	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9406		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9407	}
9408}
9409/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9410impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &i32 where T: NumLike+From<i32> {
9411	type Output = MagneticFluxDensity<T>;
9412	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9413		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9414	}
9415}
9416
9417// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9418/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9419#[cfg(feature="num-bigfloat")]
9420impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
9421	type Output = MagneticFluxDensity<T>;
9422	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9423		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9424	}
9425}
9426/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9427#[cfg(feature="num-bigfloat")]
9428impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
9429	type Output = MagneticFluxDensity<T>;
9430	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9431		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9432	}
9433}
9434/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9435#[cfg(feature="num-bigfloat")]
9436impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
9437	type Output = MagneticFluxDensity<T>;
9438	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9439		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9440	}
9441}
9442/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9443#[cfg(feature="num-bigfloat")]
9444impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
9445	type Output = MagneticFluxDensity<T>;
9446	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9447		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9448	}
9449}
9450
9451// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9452/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9453#[cfg(feature="num-complex")]
9454impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
9455	type Output = MagneticFluxDensity<T>;
9456	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9457		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9458	}
9459}
9460/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9461#[cfg(feature="num-complex")]
9462impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
9463	type Output = MagneticFluxDensity<T>;
9464	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9465		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9466	}
9467}
9468/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9469#[cfg(feature="num-complex")]
9470impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
9471	type Output = MagneticFluxDensity<T>;
9472	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9473		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9474	}
9475}
9476/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9477#[cfg(feature="num-complex")]
9478impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
9479	type Output = MagneticFluxDensity<T>;
9480	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9481		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9482	}
9483}
9484
9485// 1/InverseMagneticFluxDensity -> MagneticFluxDensity
9486/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9487#[cfg(feature="num-complex")]
9488impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
9489	type Output = MagneticFluxDensity<T>;
9490	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9491		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb}
9492	}
9493}
9494/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9495#[cfg(feature="num-complex")]
9496impl<T> core::ops::Div<InverseMagneticFluxDensity<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
9497	type Output = MagneticFluxDensity<T>;
9498	fn div(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
9499		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb}
9500	}
9501}
9502/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9503#[cfg(feature="num-complex")]
9504impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
9505	type Output = MagneticFluxDensity<T>;
9506	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9507		MagneticFluxDensity{T: T::from(self) / rhs.m2_per_Wb.clone()}
9508	}
9509}
9510/// Dividing a scalar value by a InverseMagneticFluxDensity unit value returns a value of type MagneticFluxDensity
9511#[cfg(feature="num-complex")]
9512impl<T> core::ops::Div<&InverseMagneticFluxDensity<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
9513	type Output = MagneticFluxDensity<T>;
9514	fn div(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
9515		MagneticFluxDensity{T: T::from(self.clone()) / rhs.m2_per_Wb.clone()}
9516	}
9517}
9518
9519/// The inverse of voltage unit type, defined as inverse volts in SI units
9520#[derive(UnitStruct, Debug, Clone)]
9521#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
9522pub struct InverseVoltage<T: NumLike>{
9523	/// The value of this Inverse voltage in inverse volts
9524	pub per_V: T
9525}
9526
9527impl<T> InverseVoltage<T> where T: NumLike {
9528
9529	/// Returns the standard unit name of inverse voltage: "inverse volts"
9530	pub fn unit_name() -> &'static str { "inverse volts" }
9531	
9532	/// Returns the abbreviated name or symbol of inverse voltage: "1/V" for inverse volts
9533	pub fn unit_symbol() -> &'static str { "1/V" }
9534	
9535	/// Returns a new inverse voltage value from the given number of inverse volts
9536	///
9537	/// # Arguments
9538	/// * `per_V` - Any number-like type, representing a quantity of inverse volts
9539	pub fn from_per_V(per_V: T) -> Self { InverseVoltage{per_V: per_V} }
9540	
9541	/// Returns a copy of this inverse voltage value in inverse volts
9542	pub fn to_per_V(&self) -> T { self.per_V.clone() }
9543
9544	/// Returns a new inverse voltage value from the given number of inverse volts
9545	///
9546	/// # Arguments
9547	/// * `per_volt` - Any number-like type, representing a quantity of inverse volts
9548	pub fn from_per_volt(per_volt: T) -> Self { InverseVoltage{per_V: per_volt} }
9549	
9550	/// Returns a copy of this inverse voltage value in inverse volts
9551	pub fn to_per_volt(&self) -> T { self.per_V.clone() }
9552
9553}
9554
9555impl<T> fmt::Display for InverseVoltage<T> where T: NumLike {
9556	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9557		write!(f, "{} {}", &self.per_V, Self::unit_symbol())
9558	}
9559}
9560
9561impl<T> InverseVoltage<T> where T: NumLike+From<f64> {
9562	
9563	/// Returns a copy of this inverse voltage value in inverse millivolts
9564	/// 
9565	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9566	pub fn to_per_mV(&self) -> T {
9567		return self.per_V.clone() * T::from(0.001_f64);
9568	}
9569
9570	/// Returns a new inverse voltage value from the given number of inverse millivolts
9571	/// 
9572	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9573	///
9574	/// # Arguments
9575	/// * `per_mV` - Any number-like type, representing a quantity of inverse millivolts
9576	pub fn from_per_mV(per_mV: T) -> Self {
9577		InverseVoltage{per_V: per_mV * T::from(1000.0_f64)}
9578	}
9579
9580	/// Returns a copy of this inverse voltage value in inverse microvolts
9581	/// 
9582	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9583	pub fn to_per_uV(&self) -> T {
9584		return self.per_V.clone() * T::from(1e-06_f64);
9585	}
9586
9587	/// Returns a new inverse voltage value from the given number of inverse microvolts
9588	/// 
9589	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9590	///
9591	/// # Arguments
9592	/// * `per_uV` - Any number-like type, representing a quantity of inverse microvolts
9593	pub fn from_per_uV(per_uV: T) -> Self {
9594		InverseVoltage{per_V: per_uV * T::from(1000000.0_f64)}
9595	}
9596
9597	/// Returns a copy of this inverse voltage value in inverse nanovolts
9598	/// 
9599	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9600	pub fn to_per_nV(&self) -> T {
9601		return self.per_V.clone() * T::from(1e-09_f64);
9602	}
9603
9604	/// Returns a new inverse voltage value from the given number of inverse nanovolts
9605	/// 
9606	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9607	///
9608	/// # Arguments
9609	/// * `per_nV` - Any number-like type, representing a quantity of inverse nanovolts
9610	pub fn from_per_nV(per_nV: T) -> Self {
9611		InverseVoltage{per_V: per_nV * T::from(1000000000.0_f64)}
9612	}
9613
9614	/// Returns a copy of this inverse voltage value in inverse kilovolts
9615	/// 
9616	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9617	pub fn to_per_kV(&self) -> T {
9618		return self.per_V.clone() * T::from(1000.0_f64);
9619	}
9620
9621	/// Returns a new inverse voltage value from the given number of inverse kilovolts
9622	/// 
9623	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9624	///
9625	/// # Arguments
9626	/// * `per_kV` - Any number-like type, representing a quantity of inverse kilovolts
9627	pub fn from_per_kV(per_kV: T) -> Self {
9628		InverseVoltage{per_V: per_kV * T::from(0.001_f64)}
9629	}
9630
9631	/// Returns a copy of this inverse voltage value in inverse megavolts
9632	/// 
9633	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9634	pub fn to_per_MV(&self) -> T {
9635		return self.per_V.clone() * T::from(1000000.0_f64);
9636	}
9637
9638	/// Returns a new inverse voltage value from the given number of inverse megavolts
9639	/// 
9640	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9641	///
9642	/// # Arguments
9643	/// * `per_MV` - Any number-like type, representing a quantity of inverse megavolts
9644	pub fn from_per_MV(per_MV: T) -> Self {
9645		InverseVoltage{per_V: per_MV * T::from(1e-06_f64)}
9646	}
9647
9648	/// Returns a copy of this inverse voltage value in inverse gigavolts
9649	/// 
9650	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9651	pub fn to_per_GV(&self) -> T {
9652		return self.per_V.clone() * T::from(1000000000.0_f64);
9653	}
9654
9655	/// Returns a new inverse voltage value from the given number of inverse gigavolts
9656	/// 
9657	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
9658	///
9659	/// # Arguments
9660	/// * `per_GV` - Any number-like type, representing a quantity of inverse gigavolts
9661	pub fn from_per_GV(per_GV: T) -> Self {
9662		InverseVoltage{per_V: per_GV * T::from(1e-09_f64)}
9663	}
9664
9665}
9666
9667
9668/// Multiplying a unit value by a scalar value returns a unit value
9669#[cfg(feature="num-bigfloat")]
9670impl core::ops::Mul<InverseVoltage<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
9671	type Output = InverseVoltage<num_bigfloat::BigFloat>;
9672	fn mul(self, rhs: InverseVoltage<num_bigfloat::BigFloat>) -> Self::Output {
9673		InverseVoltage{per_V: self * rhs.per_V}
9674	}
9675}
9676/// Multiplying a unit value by a scalar value returns a unit value
9677#[cfg(feature="num-bigfloat")]
9678impl core::ops::Mul<InverseVoltage<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
9679	type Output = InverseVoltage<num_bigfloat::BigFloat>;
9680	fn mul(self, rhs: InverseVoltage<num_bigfloat::BigFloat>) -> Self::Output {
9681		InverseVoltage{per_V: self.clone() * rhs.per_V}
9682	}
9683}
9684/// Multiplying a unit value by a scalar value returns a unit value
9685#[cfg(feature="num-bigfloat")]
9686impl core::ops::Mul<&InverseVoltage<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
9687	type Output = InverseVoltage<num_bigfloat::BigFloat>;
9688	fn mul(self, rhs: &InverseVoltage<num_bigfloat::BigFloat>) -> Self::Output {
9689		InverseVoltage{per_V: self * rhs.per_V.clone()}
9690	}
9691}
9692/// Multiplying a unit value by a scalar value returns a unit value
9693#[cfg(feature="num-bigfloat")]
9694impl core::ops::Mul<&InverseVoltage<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
9695	type Output = InverseVoltage<num_bigfloat::BigFloat>;
9696	fn mul(self, rhs: &InverseVoltage<num_bigfloat::BigFloat>) -> Self::Output {
9697		InverseVoltage{per_V: self.clone() * rhs.per_V.clone()}
9698	}
9699}
9700
9701/// Multiplying a unit value by a scalar value returns a unit value
9702#[cfg(feature="num-complex")]
9703impl core::ops::Mul<InverseVoltage<num_complex::Complex32>> for num_complex::Complex32 {
9704	type Output = InverseVoltage<num_complex::Complex32>;
9705	fn mul(self, rhs: InverseVoltage<num_complex::Complex32>) -> Self::Output {
9706		InverseVoltage{per_V: self * rhs.per_V}
9707	}
9708}
9709/// Multiplying a unit value by a scalar value returns a unit value
9710#[cfg(feature="num-complex")]
9711impl core::ops::Mul<InverseVoltage<num_complex::Complex32>> for &num_complex::Complex32 {
9712	type Output = InverseVoltage<num_complex::Complex32>;
9713	fn mul(self, rhs: InverseVoltage<num_complex::Complex32>) -> Self::Output {
9714		InverseVoltage{per_V: self.clone() * rhs.per_V}
9715	}
9716}
9717/// Multiplying a unit value by a scalar value returns a unit value
9718#[cfg(feature="num-complex")]
9719impl core::ops::Mul<&InverseVoltage<num_complex::Complex32>> for num_complex::Complex32 {
9720	type Output = InverseVoltage<num_complex::Complex32>;
9721	fn mul(self, rhs: &InverseVoltage<num_complex::Complex32>) -> Self::Output {
9722		InverseVoltage{per_V: self * rhs.per_V.clone()}
9723	}
9724}
9725/// Multiplying a unit value by a scalar value returns a unit value
9726#[cfg(feature="num-complex")]
9727impl core::ops::Mul<&InverseVoltage<num_complex::Complex32>> for &num_complex::Complex32 {
9728	type Output = InverseVoltage<num_complex::Complex32>;
9729	fn mul(self, rhs: &InverseVoltage<num_complex::Complex32>) -> Self::Output {
9730		InverseVoltage{per_V: self.clone() * rhs.per_V.clone()}
9731	}
9732}
9733
9734/// Multiplying a unit value by a scalar value returns a unit value
9735#[cfg(feature="num-complex")]
9736impl core::ops::Mul<InverseVoltage<num_complex::Complex64>> for num_complex::Complex64 {
9737	type Output = InverseVoltage<num_complex::Complex64>;
9738	fn mul(self, rhs: InverseVoltage<num_complex::Complex64>) -> Self::Output {
9739		InverseVoltage{per_V: self * rhs.per_V}
9740	}
9741}
9742/// Multiplying a unit value by a scalar value returns a unit value
9743#[cfg(feature="num-complex")]
9744impl core::ops::Mul<InverseVoltage<num_complex::Complex64>> for &num_complex::Complex64 {
9745	type Output = InverseVoltage<num_complex::Complex64>;
9746	fn mul(self, rhs: InverseVoltage<num_complex::Complex64>) -> Self::Output {
9747		InverseVoltage{per_V: self.clone() * rhs.per_V}
9748	}
9749}
9750/// Multiplying a unit value by a scalar value returns a unit value
9751#[cfg(feature="num-complex")]
9752impl core::ops::Mul<&InverseVoltage<num_complex::Complex64>> for num_complex::Complex64 {
9753	type Output = InverseVoltage<num_complex::Complex64>;
9754	fn mul(self, rhs: &InverseVoltage<num_complex::Complex64>) -> Self::Output {
9755		InverseVoltage{per_V: self * rhs.per_V.clone()}
9756	}
9757}
9758/// Multiplying a unit value by a scalar value returns a unit value
9759#[cfg(feature="num-complex")]
9760impl core::ops::Mul<&InverseVoltage<num_complex::Complex64>> for &num_complex::Complex64 {
9761	type Output = InverseVoltage<num_complex::Complex64>;
9762	fn mul(self, rhs: &InverseVoltage<num_complex::Complex64>) -> Self::Output {
9763		InverseVoltage{per_V: self.clone() * rhs.per_V.clone()}
9764	}
9765}
9766
9767
9768
9769
9770// InverseVoltage * Current -> Conductance
9771/// Multiplying a InverseVoltage by a Current returns a value of type Conductance
9772impl<T> core::ops::Mul<Current<T>> for InverseVoltage<T> where T: NumLike {
9773	type Output = Conductance<T>;
9774	fn mul(self, rhs: Current<T>) -> Self::Output {
9775		Conductance{S: self.per_V * rhs.A}
9776	}
9777}
9778/// Multiplying a InverseVoltage by a Current returns a value of type Conductance
9779impl<T> core::ops::Mul<Current<T>> for &InverseVoltage<T> where T: NumLike {
9780	type Output = Conductance<T>;
9781	fn mul(self, rhs: Current<T>) -> Self::Output {
9782		Conductance{S: self.per_V.clone() * rhs.A}
9783	}
9784}
9785/// Multiplying a InverseVoltage by a Current returns a value of type Conductance
9786impl<T> core::ops::Mul<&Current<T>> for InverseVoltage<T> where T: NumLike {
9787	type Output = Conductance<T>;
9788	fn mul(self, rhs: &Current<T>) -> Self::Output {
9789		Conductance{S: self.per_V * rhs.A.clone()}
9790	}
9791}
9792/// Multiplying a InverseVoltage by a Current returns a value of type Conductance
9793impl<T> core::ops::Mul<&Current<T>> for &InverseVoltage<T> where T: NumLike {
9794	type Output = Conductance<T>;
9795	fn mul(self, rhs: &Current<T>) -> Self::Output {
9796		Conductance{S: self.per_V.clone() * rhs.A.clone()}
9797	}
9798}
9799
9800// InverseVoltage / Current -> InversePower
9801/// Dividing a InverseVoltage by a Current returns a value of type InversePower
9802impl<T> core::ops::Div<Current<T>> for InverseVoltage<T> where T: NumLike {
9803	type Output = InversePower<T>;
9804	fn div(self, rhs: Current<T>) -> Self::Output {
9805		InversePower{per_W: self.per_V / rhs.A}
9806	}
9807}
9808/// Dividing a InverseVoltage by a Current returns a value of type InversePower
9809impl<T> core::ops::Div<Current<T>> for &InverseVoltage<T> where T: NumLike {
9810	type Output = InversePower<T>;
9811	fn div(self, rhs: Current<T>) -> Self::Output {
9812		InversePower{per_W: self.per_V.clone() / rhs.A}
9813	}
9814}
9815/// Dividing a InverseVoltage by a Current returns a value of type InversePower
9816impl<T> core::ops::Div<&Current<T>> for InverseVoltage<T> where T: NumLike {
9817	type Output = InversePower<T>;
9818	fn div(self, rhs: &Current<T>) -> Self::Output {
9819		InversePower{per_W: self.per_V / rhs.A.clone()}
9820	}
9821}
9822/// Dividing a InverseVoltage by a Current returns a value of type InversePower
9823impl<T> core::ops::Div<&Current<T>> for &InverseVoltage<T> where T: NumLike {
9824	type Output = InversePower<T>;
9825	fn div(self, rhs: &Current<T>) -> Self::Output {
9826		InversePower{per_W: self.per_V.clone() / rhs.A.clone()}
9827	}
9828}
9829
9830// InverseVoltage * InverseCurrent -> InversePower
9831/// Multiplying a InverseVoltage by a InverseCurrent returns a value of type InversePower
9832impl<T> core::ops::Mul<InverseCurrent<T>> for InverseVoltage<T> where T: NumLike {
9833	type Output = InversePower<T>;
9834	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
9835		InversePower{per_W: self.per_V * rhs.per_A}
9836	}
9837}
9838/// Multiplying a InverseVoltage by a InverseCurrent returns a value of type InversePower
9839impl<T> core::ops::Mul<InverseCurrent<T>> for &InverseVoltage<T> where T: NumLike {
9840	type Output = InversePower<T>;
9841	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
9842		InversePower{per_W: self.per_V.clone() * rhs.per_A}
9843	}
9844}
9845/// Multiplying a InverseVoltage by a InverseCurrent returns a value of type InversePower
9846impl<T> core::ops::Mul<&InverseCurrent<T>> for InverseVoltage<T> where T: NumLike {
9847	type Output = InversePower<T>;
9848	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
9849		InversePower{per_W: self.per_V * rhs.per_A.clone()}
9850	}
9851}
9852/// Multiplying a InverseVoltage by a InverseCurrent returns a value of type InversePower
9853impl<T> core::ops::Mul<&InverseCurrent<T>> for &InverseVoltage<T> where T: NumLike {
9854	type Output = InversePower<T>;
9855	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
9856		InversePower{per_W: self.per_V.clone() * rhs.per_A.clone()}
9857	}
9858}
9859
9860// InverseVoltage / InverseCurrent -> Conductance
9861/// Dividing a InverseVoltage by a InverseCurrent returns a value of type Conductance
9862impl<T> core::ops::Div<InverseCurrent<T>> for InverseVoltage<T> where T: NumLike {
9863	type Output = Conductance<T>;
9864	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
9865		Conductance{S: self.per_V / rhs.per_A}
9866	}
9867}
9868/// Dividing a InverseVoltage by a InverseCurrent returns a value of type Conductance
9869impl<T> core::ops::Div<InverseCurrent<T>> for &InverseVoltage<T> where T: NumLike {
9870	type Output = Conductance<T>;
9871	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
9872		Conductance{S: self.per_V.clone() / rhs.per_A}
9873	}
9874}
9875/// Dividing a InverseVoltage by a InverseCurrent returns a value of type Conductance
9876impl<T> core::ops::Div<&InverseCurrent<T>> for InverseVoltage<T> where T: NumLike {
9877	type Output = Conductance<T>;
9878	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
9879		Conductance{S: self.per_V / rhs.per_A.clone()}
9880	}
9881}
9882/// Dividing a InverseVoltage by a InverseCurrent returns a value of type Conductance
9883impl<T> core::ops::Div<&InverseCurrent<T>> for &InverseVoltage<T> where T: NumLike {
9884	type Output = Conductance<T>;
9885	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
9886		Conductance{S: self.per_V.clone() / rhs.per_A.clone()}
9887	}
9888}
9889
9890// InverseVoltage / Time -> InverseMagneticFlux
9891/// Dividing a InverseVoltage by a Time returns a value of type InverseMagneticFlux
9892impl<T> core::ops::Div<Time<T>> for InverseVoltage<T> where T: NumLike {
9893	type Output = InverseMagneticFlux<T>;
9894	fn div(self, rhs: Time<T>) -> Self::Output {
9895		InverseMagneticFlux{per_Wb: self.per_V / rhs.s}
9896	}
9897}
9898/// Dividing a InverseVoltage by a Time returns a value of type InverseMagneticFlux
9899impl<T> core::ops::Div<Time<T>> for &InverseVoltage<T> where T: NumLike {
9900	type Output = InverseMagneticFlux<T>;
9901	fn div(self, rhs: Time<T>) -> Self::Output {
9902		InverseMagneticFlux{per_Wb: self.per_V.clone() / rhs.s}
9903	}
9904}
9905/// Dividing a InverseVoltage by a Time returns a value of type InverseMagneticFlux
9906impl<T> core::ops::Div<&Time<T>> for InverseVoltage<T> where T: NumLike {
9907	type Output = InverseMagneticFlux<T>;
9908	fn div(self, rhs: &Time<T>) -> Self::Output {
9909		InverseMagneticFlux{per_Wb: self.per_V / rhs.s.clone()}
9910	}
9911}
9912/// Dividing a InverseVoltage by a Time returns a value of type InverseMagneticFlux
9913impl<T> core::ops::Div<&Time<T>> for &InverseVoltage<T> where T: NumLike {
9914	type Output = InverseMagneticFlux<T>;
9915	fn div(self, rhs: &Time<T>) -> Self::Output {
9916		InverseMagneticFlux{per_Wb: self.per_V.clone() / rhs.s.clone()}
9917	}
9918}
9919
9920// InverseVoltage / Capacitance -> InverseCharge
9921/// Dividing a InverseVoltage by a Capacitance returns a value of type InverseCharge
9922impl<T> core::ops::Div<Capacitance<T>> for InverseVoltage<T> where T: NumLike {
9923	type Output = InverseCharge<T>;
9924	fn div(self, rhs: Capacitance<T>) -> Self::Output {
9925		InverseCharge{per_C: self.per_V / rhs.F}
9926	}
9927}
9928/// Dividing a InverseVoltage by a Capacitance returns a value of type InverseCharge
9929impl<T> core::ops::Div<Capacitance<T>> for &InverseVoltage<T> where T: NumLike {
9930	type Output = InverseCharge<T>;
9931	fn div(self, rhs: Capacitance<T>) -> Self::Output {
9932		InverseCharge{per_C: self.per_V.clone() / rhs.F}
9933	}
9934}
9935/// Dividing a InverseVoltage by a Capacitance returns a value of type InverseCharge
9936impl<T> core::ops::Div<&Capacitance<T>> for InverseVoltage<T> where T: NumLike {
9937	type Output = InverseCharge<T>;
9938	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
9939		InverseCharge{per_C: self.per_V / rhs.F.clone()}
9940	}
9941}
9942/// Dividing a InverseVoltage by a Capacitance returns a value of type InverseCharge
9943impl<T> core::ops::Div<&Capacitance<T>> for &InverseVoltage<T> where T: NumLike {
9944	type Output = InverseCharge<T>;
9945	fn div(self, rhs: &Capacitance<T>) -> Self::Output {
9946		InverseCharge{per_C: self.per_V.clone() / rhs.F.clone()}
9947	}
9948}
9949
9950// InverseVoltage * Charge -> Capacitance
9951/// Multiplying a InverseVoltage by a Charge returns a value of type Capacitance
9952impl<T> core::ops::Mul<Charge<T>> for InverseVoltage<T> where T: NumLike {
9953	type Output = Capacitance<T>;
9954	fn mul(self, rhs: Charge<T>) -> Self::Output {
9955		Capacitance{F: self.per_V * rhs.C}
9956	}
9957}
9958/// Multiplying a InverseVoltage by a Charge returns a value of type Capacitance
9959impl<T> core::ops::Mul<Charge<T>> for &InverseVoltage<T> where T: NumLike {
9960	type Output = Capacitance<T>;
9961	fn mul(self, rhs: Charge<T>) -> Self::Output {
9962		Capacitance{F: self.per_V.clone() * rhs.C}
9963	}
9964}
9965/// Multiplying a InverseVoltage by a Charge returns a value of type Capacitance
9966impl<T> core::ops::Mul<&Charge<T>> for InverseVoltage<T> where T: NumLike {
9967	type Output = Capacitance<T>;
9968	fn mul(self, rhs: &Charge<T>) -> Self::Output {
9969		Capacitance{F: self.per_V * rhs.C.clone()}
9970	}
9971}
9972/// Multiplying a InverseVoltage by a Charge returns a value of type Capacitance
9973impl<T> core::ops::Mul<&Charge<T>> for &InverseVoltage<T> where T: NumLike {
9974	type Output = Capacitance<T>;
9975	fn mul(self, rhs: &Charge<T>) -> Self::Output {
9976		Capacitance{F: self.per_V.clone() * rhs.C.clone()}
9977	}
9978}
9979
9980// InverseVoltage / Charge -> InverseEnergy
9981/// Dividing a InverseVoltage by a Charge returns a value of type InverseEnergy
9982impl<T> core::ops::Div<Charge<T>> for InverseVoltage<T> where T: NumLike {
9983	type Output = InverseEnergy<T>;
9984	fn div(self, rhs: Charge<T>) -> Self::Output {
9985		InverseEnergy{per_J: self.per_V / rhs.C}
9986	}
9987}
9988/// Dividing a InverseVoltage by a Charge returns a value of type InverseEnergy
9989impl<T> core::ops::Div<Charge<T>> for &InverseVoltage<T> where T: NumLike {
9990	type Output = InverseEnergy<T>;
9991	fn div(self, rhs: Charge<T>) -> Self::Output {
9992		InverseEnergy{per_J: self.per_V.clone() / rhs.C}
9993	}
9994}
9995/// Dividing a InverseVoltage by a Charge returns a value of type InverseEnergy
9996impl<T> core::ops::Div<&Charge<T>> for InverseVoltage<T> where T: NumLike {
9997	type Output = InverseEnergy<T>;
9998	fn div(self, rhs: &Charge<T>) -> Self::Output {
9999		InverseEnergy{per_J: self.per_V / rhs.C.clone()}
10000	}
10001}
10002/// Dividing a InverseVoltage by a Charge returns a value of type InverseEnergy
10003impl<T> core::ops::Div<&Charge<T>> for &InverseVoltage<T> where T: NumLike {
10004	type Output = InverseEnergy<T>;
10005	fn div(self, rhs: &Charge<T>) -> Self::Output {
10006		InverseEnergy{per_J: self.per_V.clone() / rhs.C.clone()}
10007	}
10008}
10009
10010// InverseVoltage / Conductance -> InverseCurrent
10011/// Dividing a InverseVoltage by a Conductance returns a value of type InverseCurrent
10012impl<T> core::ops::Div<Conductance<T>> for InverseVoltage<T> where T: NumLike {
10013	type Output = InverseCurrent<T>;
10014	fn div(self, rhs: Conductance<T>) -> Self::Output {
10015		InverseCurrent{per_A: self.per_V / rhs.S}
10016	}
10017}
10018/// Dividing a InverseVoltage by a Conductance returns a value of type InverseCurrent
10019impl<T> core::ops::Div<Conductance<T>> for &InverseVoltage<T> where T: NumLike {
10020	type Output = InverseCurrent<T>;
10021	fn div(self, rhs: Conductance<T>) -> Self::Output {
10022		InverseCurrent{per_A: self.per_V.clone() / rhs.S}
10023	}
10024}
10025/// Dividing a InverseVoltage by a Conductance returns a value of type InverseCurrent
10026impl<T> core::ops::Div<&Conductance<T>> for InverseVoltage<T> where T: NumLike {
10027	type Output = InverseCurrent<T>;
10028	fn div(self, rhs: &Conductance<T>) -> Self::Output {
10029		InverseCurrent{per_A: self.per_V / rhs.S.clone()}
10030	}
10031}
10032/// Dividing a InverseVoltage by a Conductance returns a value of type InverseCurrent
10033impl<T> core::ops::Div<&Conductance<T>> for &InverseVoltage<T> where T: NumLike {
10034	type Output = InverseCurrent<T>;
10035	fn div(self, rhs: &Conductance<T>) -> Self::Output {
10036		InverseCurrent{per_A: self.per_V.clone() / rhs.S.clone()}
10037	}
10038}
10039
10040// InverseVoltage * Elastance -> InverseCharge
10041/// Multiplying a InverseVoltage by a Elastance returns a value of type InverseCharge
10042impl<T> core::ops::Mul<Elastance<T>> for InverseVoltage<T> where T: NumLike {
10043	type Output = InverseCharge<T>;
10044	fn mul(self, rhs: Elastance<T>) -> Self::Output {
10045		InverseCharge{per_C: self.per_V * rhs.per_F}
10046	}
10047}
10048/// Multiplying a InverseVoltage by a Elastance returns a value of type InverseCharge
10049impl<T> core::ops::Mul<Elastance<T>> for &InverseVoltage<T> where T: NumLike {
10050	type Output = InverseCharge<T>;
10051	fn mul(self, rhs: Elastance<T>) -> Self::Output {
10052		InverseCharge{per_C: self.per_V.clone() * rhs.per_F}
10053	}
10054}
10055/// Multiplying a InverseVoltage by a Elastance returns a value of type InverseCharge
10056impl<T> core::ops::Mul<&Elastance<T>> for InverseVoltage<T> where T: NumLike {
10057	type Output = InverseCharge<T>;
10058	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
10059		InverseCharge{per_C: self.per_V * rhs.per_F.clone()}
10060	}
10061}
10062/// Multiplying a InverseVoltage by a Elastance returns a value of type InverseCharge
10063impl<T> core::ops::Mul<&Elastance<T>> for &InverseVoltage<T> where T: NumLike {
10064	type Output = InverseCharge<T>;
10065	fn mul(self, rhs: &Elastance<T>) -> Self::Output {
10066		InverseCharge{per_C: self.per_V.clone() * rhs.per_F.clone()}
10067	}
10068}
10069
10070// InverseVoltage * InverseCharge -> InverseEnergy
10071/// Multiplying a InverseVoltage by a InverseCharge returns a value of type InverseEnergy
10072impl<T> core::ops::Mul<InverseCharge<T>> for InverseVoltage<T> where T: NumLike {
10073	type Output = InverseEnergy<T>;
10074	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
10075		InverseEnergy{per_J: self.per_V * rhs.per_C}
10076	}
10077}
10078/// Multiplying a InverseVoltage by a InverseCharge returns a value of type InverseEnergy
10079impl<T> core::ops::Mul<InverseCharge<T>> for &InverseVoltage<T> where T: NumLike {
10080	type Output = InverseEnergy<T>;
10081	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
10082		InverseEnergy{per_J: self.per_V.clone() * rhs.per_C}
10083	}
10084}
10085/// Multiplying a InverseVoltage by a InverseCharge returns a value of type InverseEnergy
10086impl<T> core::ops::Mul<&InverseCharge<T>> for InverseVoltage<T> where T: NumLike {
10087	type Output = InverseEnergy<T>;
10088	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
10089		InverseEnergy{per_J: self.per_V * rhs.per_C.clone()}
10090	}
10091}
10092/// Multiplying a InverseVoltage by a InverseCharge returns a value of type InverseEnergy
10093impl<T> core::ops::Mul<&InverseCharge<T>> for &InverseVoltage<T> where T: NumLike {
10094	type Output = InverseEnergy<T>;
10095	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
10096		InverseEnergy{per_J: self.per_V.clone() * rhs.per_C.clone()}
10097	}
10098}
10099
10100// InverseVoltage / InverseCharge -> Capacitance
10101/// Dividing a InverseVoltage by a InverseCharge returns a value of type Capacitance
10102impl<T> core::ops::Div<InverseCharge<T>> for InverseVoltage<T> where T: NumLike {
10103	type Output = Capacitance<T>;
10104	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
10105		Capacitance{F: self.per_V / rhs.per_C}
10106	}
10107}
10108/// Dividing a InverseVoltage by a InverseCharge returns a value of type Capacitance
10109impl<T> core::ops::Div<InverseCharge<T>> for &InverseVoltage<T> where T: NumLike {
10110	type Output = Capacitance<T>;
10111	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
10112		Capacitance{F: self.per_V.clone() / rhs.per_C}
10113	}
10114}
10115/// Dividing a InverseVoltage by a InverseCharge returns a value of type Capacitance
10116impl<T> core::ops::Div<&InverseCharge<T>> for InverseVoltage<T> where T: NumLike {
10117	type Output = Capacitance<T>;
10118	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
10119		Capacitance{F: self.per_V / rhs.per_C.clone()}
10120	}
10121}
10122/// Dividing a InverseVoltage by a InverseCharge returns a value of type Capacitance
10123impl<T> core::ops::Div<&InverseCharge<T>> for &InverseVoltage<T> where T: NumLike {
10124	type Output = Capacitance<T>;
10125	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
10126		Capacitance{F: self.per_V.clone() / rhs.per_C.clone()}
10127	}
10128}
10129
10130// InverseVoltage / InverseMagneticFlux -> Time
10131/// Dividing a InverseVoltage by a InverseMagneticFlux returns a value of type Time
10132impl<T> core::ops::Div<InverseMagneticFlux<T>> for InverseVoltage<T> where T: NumLike {
10133	type Output = Time<T>;
10134	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
10135		Time{s: self.per_V / rhs.per_Wb}
10136	}
10137}
10138/// Dividing a InverseVoltage by a InverseMagneticFlux returns a value of type Time
10139impl<T> core::ops::Div<InverseMagneticFlux<T>> for &InverseVoltage<T> where T: NumLike {
10140	type Output = Time<T>;
10141	fn div(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
10142		Time{s: self.per_V.clone() / rhs.per_Wb}
10143	}
10144}
10145/// Dividing a InverseVoltage by a InverseMagneticFlux returns a value of type Time
10146impl<T> core::ops::Div<&InverseMagneticFlux<T>> for InverseVoltage<T> where T: NumLike {
10147	type Output = Time<T>;
10148	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
10149		Time{s: self.per_V / rhs.per_Wb.clone()}
10150	}
10151}
10152/// Dividing a InverseVoltage by a InverseMagneticFlux returns a value of type Time
10153impl<T> core::ops::Div<&InverseMagneticFlux<T>> for &InverseVoltage<T> where T: NumLike {
10154	type Output = Time<T>;
10155	fn div(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
10156		Time{s: self.per_V.clone() / rhs.per_Wb.clone()}
10157	}
10158}
10159
10160// InverseVoltage * MagneticFlux -> Time
10161/// Multiplying a InverseVoltage by a MagneticFlux returns a value of type Time
10162impl<T> core::ops::Mul<MagneticFlux<T>> for InverseVoltage<T> where T: NumLike {
10163	type Output = Time<T>;
10164	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
10165		Time{s: self.per_V * rhs.Wb}
10166	}
10167}
10168/// Multiplying a InverseVoltage by a MagneticFlux returns a value of type Time
10169impl<T> core::ops::Mul<MagneticFlux<T>> for &InverseVoltage<T> where T: NumLike {
10170	type Output = Time<T>;
10171	fn mul(self, rhs: MagneticFlux<T>) -> Self::Output {
10172		Time{s: self.per_V.clone() * rhs.Wb}
10173	}
10174}
10175/// Multiplying a InverseVoltage by a MagneticFlux returns a value of type Time
10176impl<T> core::ops::Mul<&MagneticFlux<T>> for InverseVoltage<T> where T: NumLike {
10177	type Output = Time<T>;
10178	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
10179		Time{s: self.per_V * rhs.Wb.clone()}
10180	}
10181}
10182/// Multiplying a InverseVoltage by a MagneticFlux returns a value of type Time
10183impl<T> core::ops::Mul<&MagneticFlux<T>> for &InverseVoltage<T> where T: NumLike {
10184	type Output = Time<T>;
10185	fn mul(self, rhs: &MagneticFlux<T>) -> Self::Output {
10186		Time{s: self.per_V.clone() * rhs.Wb.clone()}
10187	}
10188}
10189
10190// InverseVoltage * Resistance -> InverseCurrent
10191/// Multiplying a InverseVoltage by a Resistance returns a value of type InverseCurrent
10192impl<T> core::ops::Mul<Resistance<T>> for InverseVoltage<T> where T: NumLike {
10193	type Output = InverseCurrent<T>;
10194	fn mul(self, rhs: Resistance<T>) -> Self::Output {
10195		InverseCurrent{per_A: self.per_V * rhs.Ohm}
10196	}
10197}
10198/// Multiplying a InverseVoltage by a Resistance returns a value of type InverseCurrent
10199impl<T> core::ops::Mul<Resistance<T>> for &InverseVoltage<T> where T: NumLike {
10200	type Output = InverseCurrent<T>;
10201	fn mul(self, rhs: Resistance<T>) -> Self::Output {
10202		InverseCurrent{per_A: self.per_V.clone() * rhs.Ohm}
10203	}
10204}
10205/// Multiplying a InverseVoltage by a Resistance returns a value of type InverseCurrent
10206impl<T> core::ops::Mul<&Resistance<T>> for InverseVoltage<T> where T: NumLike {
10207	type Output = InverseCurrent<T>;
10208	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
10209		InverseCurrent{per_A: self.per_V * rhs.Ohm.clone()}
10210	}
10211}
10212/// Multiplying a InverseVoltage by a Resistance returns a value of type InverseCurrent
10213impl<T> core::ops::Mul<&Resistance<T>> for &InverseVoltage<T> where T: NumLike {
10214	type Output = InverseCurrent<T>;
10215	fn mul(self, rhs: &Resistance<T>) -> Self::Output {
10216		InverseCurrent{per_A: self.per_V.clone() * rhs.Ohm.clone()}
10217	}
10218}
10219
10220// InverseVoltage * Energy -> Charge
10221/// Multiplying a InverseVoltage by a Energy returns a value of type Charge
10222impl<T> core::ops::Mul<Energy<T>> for InverseVoltage<T> where T: NumLike {
10223	type Output = Charge<T>;
10224	fn mul(self, rhs: Energy<T>) -> Self::Output {
10225		Charge{C: self.per_V * rhs.J}
10226	}
10227}
10228/// Multiplying a InverseVoltage by a Energy returns a value of type Charge
10229impl<T> core::ops::Mul<Energy<T>> for &InverseVoltage<T> where T: NumLike {
10230	type Output = Charge<T>;
10231	fn mul(self, rhs: Energy<T>) -> Self::Output {
10232		Charge{C: self.per_V.clone() * rhs.J}
10233	}
10234}
10235/// Multiplying a InverseVoltage by a Energy returns a value of type Charge
10236impl<T> core::ops::Mul<&Energy<T>> for InverseVoltage<T> where T: NumLike {
10237	type Output = Charge<T>;
10238	fn mul(self, rhs: &Energy<T>) -> Self::Output {
10239		Charge{C: self.per_V * rhs.J.clone()}
10240	}
10241}
10242/// Multiplying a InverseVoltage by a Energy returns a value of type Charge
10243impl<T> core::ops::Mul<&Energy<T>> for &InverseVoltage<T> where T: NumLike {
10244	type Output = Charge<T>;
10245	fn mul(self, rhs: &Energy<T>) -> Self::Output {
10246		Charge{C: self.per_V.clone() * rhs.J.clone()}
10247	}
10248}
10249
10250// InverseVoltage * Torque -> Charge
10251/// Multiplying a InverseVoltage by a Torque returns a value of type Charge
10252impl<T> core::ops::Mul<Torque<T>> for InverseVoltage<T> where T: NumLike {
10253	type Output = Charge<T>;
10254	fn mul(self, rhs: Torque<T>) -> Self::Output {
10255		Charge{C: self.per_V * rhs.Nm}
10256	}
10257}
10258/// Multiplying a InverseVoltage by a Torque returns a value of type Charge
10259impl<T> core::ops::Mul<Torque<T>> for &InverseVoltage<T> where T: NumLike {
10260	type Output = Charge<T>;
10261	fn mul(self, rhs: Torque<T>) -> Self::Output {
10262		Charge{C: self.per_V.clone() * rhs.Nm}
10263	}
10264}
10265/// Multiplying a InverseVoltage by a Torque returns a value of type Charge
10266impl<T> core::ops::Mul<&Torque<T>> for InverseVoltage<T> where T: NumLike {
10267	type Output = Charge<T>;
10268	fn mul(self, rhs: &Torque<T>) -> Self::Output {
10269		Charge{C: self.per_V * rhs.Nm.clone()}
10270	}
10271}
10272/// Multiplying a InverseVoltage by a Torque returns a value of type Charge
10273impl<T> core::ops::Mul<&Torque<T>> for &InverseVoltage<T> where T: NumLike {
10274	type Output = Charge<T>;
10275	fn mul(self, rhs: &Torque<T>) -> Self::Output {
10276		Charge{C: self.per_V.clone() * rhs.Nm.clone()}
10277	}
10278}
10279
10280// InverseVoltage * Frequency -> InverseMagneticFlux
10281/// Multiplying a InverseVoltage by a Frequency returns a value of type InverseMagneticFlux
10282impl<T> core::ops::Mul<Frequency<T>> for InverseVoltage<T> where T: NumLike {
10283	type Output = InverseMagneticFlux<T>;
10284	fn mul(self, rhs: Frequency<T>) -> Self::Output {
10285		InverseMagneticFlux{per_Wb: self.per_V * rhs.Hz}
10286	}
10287}
10288/// Multiplying a InverseVoltage by a Frequency returns a value of type InverseMagneticFlux
10289impl<T> core::ops::Mul<Frequency<T>> for &InverseVoltage<T> where T: NumLike {
10290	type Output = InverseMagneticFlux<T>;
10291	fn mul(self, rhs: Frequency<T>) -> Self::Output {
10292		InverseMagneticFlux{per_Wb: self.per_V.clone() * rhs.Hz}
10293	}
10294}
10295/// Multiplying a InverseVoltage by a Frequency returns a value of type InverseMagneticFlux
10296impl<T> core::ops::Mul<&Frequency<T>> for InverseVoltage<T> where T: NumLike {
10297	type Output = InverseMagneticFlux<T>;
10298	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
10299		InverseMagneticFlux{per_Wb: self.per_V * rhs.Hz.clone()}
10300	}
10301}
10302/// Multiplying a InverseVoltage by a Frequency returns a value of type InverseMagneticFlux
10303impl<T> core::ops::Mul<&Frequency<T>> for &InverseVoltage<T> where T: NumLike {
10304	type Output = InverseMagneticFlux<T>;
10305	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
10306		InverseMagneticFlux{per_Wb: self.per_V.clone() * rhs.Hz.clone()}
10307	}
10308}
10309
10310// InverseVoltage / InverseEnergy -> Charge
10311/// Dividing a InverseVoltage by a InverseEnergy returns a value of type Charge
10312impl<T> core::ops::Div<InverseEnergy<T>> for InverseVoltage<T> where T: NumLike {
10313	type Output = Charge<T>;
10314	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
10315		Charge{C: self.per_V / rhs.per_J}
10316	}
10317}
10318/// Dividing a InverseVoltage by a InverseEnergy returns a value of type Charge
10319impl<T> core::ops::Div<InverseEnergy<T>> for &InverseVoltage<T> where T: NumLike {
10320	type Output = Charge<T>;
10321	fn div(self, rhs: InverseEnergy<T>) -> Self::Output {
10322		Charge{C: self.per_V.clone() / rhs.per_J}
10323	}
10324}
10325/// Dividing a InverseVoltage by a InverseEnergy returns a value of type Charge
10326impl<T> core::ops::Div<&InverseEnergy<T>> for InverseVoltage<T> where T: NumLike {
10327	type Output = Charge<T>;
10328	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
10329		Charge{C: self.per_V / rhs.per_J.clone()}
10330	}
10331}
10332/// Dividing a InverseVoltage by a InverseEnergy returns a value of type Charge
10333impl<T> core::ops::Div<&InverseEnergy<T>> for &InverseVoltage<T> where T: NumLike {
10334	type Output = Charge<T>;
10335	fn div(self, rhs: &InverseEnergy<T>) -> Self::Output {
10336		Charge{C: self.per_V.clone() / rhs.per_J.clone()}
10337	}
10338}
10339
10340// InverseVoltage / InverseTorque -> Charge
10341/// Dividing a InverseVoltage by a InverseTorque returns a value of type Charge
10342impl<T> core::ops::Div<InverseTorque<T>> for InverseVoltage<T> where T: NumLike {
10343	type Output = Charge<T>;
10344	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
10345		Charge{C: self.per_V / rhs.per_Nm}
10346	}
10347}
10348/// Dividing a InverseVoltage by a InverseTorque returns a value of type Charge
10349impl<T> core::ops::Div<InverseTorque<T>> for &InverseVoltage<T> where T: NumLike {
10350	type Output = Charge<T>;
10351	fn div(self, rhs: InverseTorque<T>) -> Self::Output {
10352		Charge{C: self.per_V.clone() / rhs.per_Nm}
10353	}
10354}
10355/// Dividing a InverseVoltage by a InverseTorque returns a value of type Charge
10356impl<T> core::ops::Div<&InverseTorque<T>> for InverseVoltage<T> where T: NumLike {
10357	type Output = Charge<T>;
10358	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
10359		Charge{C: self.per_V / rhs.per_Nm.clone()}
10360	}
10361}
10362/// Dividing a InverseVoltage by a InverseTorque returns a value of type Charge
10363impl<T> core::ops::Div<&InverseTorque<T>> for &InverseVoltage<T> where T: NumLike {
10364	type Output = Charge<T>;
10365	fn div(self, rhs: &InverseTorque<T>) -> Self::Output {
10366		Charge{C: self.per_V.clone() / rhs.per_Nm.clone()}
10367	}
10368}
10369
10370// InverseVoltage / InversePower -> Current
10371/// Dividing a InverseVoltage by a InversePower returns a value of type Current
10372impl<T> core::ops::Div<InversePower<T>> for InverseVoltage<T> where T: NumLike {
10373	type Output = Current<T>;
10374	fn div(self, rhs: InversePower<T>) -> Self::Output {
10375		Current{A: self.per_V / rhs.per_W}
10376	}
10377}
10378/// Dividing a InverseVoltage by a InversePower returns a value of type Current
10379impl<T> core::ops::Div<InversePower<T>> for &InverseVoltage<T> where T: NumLike {
10380	type Output = Current<T>;
10381	fn div(self, rhs: InversePower<T>) -> Self::Output {
10382		Current{A: self.per_V.clone() / rhs.per_W}
10383	}
10384}
10385/// Dividing a InverseVoltage by a InversePower returns a value of type Current
10386impl<T> core::ops::Div<&InversePower<T>> for InverseVoltage<T> where T: NumLike {
10387	type Output = Current<T>;
10388	fn div(self, rhs: &InversePower<T>) -> Self::Output {
10389		Current{A: self.per_V / rhs.per_W.clone()}
10390	}
10391}
10392/// Dividing a InverseVoltage by a InversePower returns a value of type Current
10393impl<T> core::ops::Div<&InversePower<T>> for &InverseVoltage<T> where T: NumLike {
10394	type Output = Current<T>;
10395	fn div(self, rhs: &InversePower<T>) -> Self::Output {
10396		Current{A: self.per_V.clone() / rhs.per_W.clone()}
10397	}
10398}
10399
10400// InverseVoltage * Power -> Current
10401/// Multiplying a InverseVoltage by a Power returns a value of type Current
10402impl<T> core::ops::Mul<Power<T>> for InverseVoltage<T> where T: NumLike {
10403	type Output = Current<T>;
10404	fn mul(self, rhs: Power<T>) -> Self::Output {
10405		Current{A: self.per_V * rhs.W}
10406	}
10407}
10408/// Multiplying a InverseVoltage by a Power returns a value of type Current
10409impl<T> core::ops::Mul<Power<T>> for &InverseVoltage<T> where T: NumLike {
10410	type Output = Current<T>;
10411	fn mul(self, rhs: Power<T>) -> Self::Output {
10412		Current{A: self.per_V.clone() * rhs.W}
10413	}
10414}
10415/// Multiplying a InverseVoltage by a Power returns a value of type Current
10416impl<T> core::ops::Mul<&Power<T>> for InverseVoltage<T> where T: NumLike {
10417	type Output = Current<T>;
10418	fn mul(self, rhs: &Power<T>) -> Self::Output {
10419		Current{A: self.per_V * rhs.W.clone()}
10420	}
10421}
10422/// Multiplying a InverseVoltage by a Power returns a value of type Current
10423impl<T> core::ops::Mul<&Power<T>> for &InverseVoltage<T> where T: NumLike {
10424	type Output = Current<T>;
10425	fn mul(self, rhs: &Power<T>) -> Self::Output {
10426		Current{A: self.per_V.clone() * rhs.W.clone()}
10427	}
10428}
10429
10430// 1/InverseVoltage -> Voltage
10431/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10432impl<T> core::ops::Div<InverseVoltage<T>> for f64 where T: NumLike+From<f64> {
10433	type Output = Voltage<T>;
10434	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10435		Voltage{V: T::from(self) / rhs.per_V}
10436	}
10437}
10438/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10439impl<T> core::ops::Div<InverseVoltage<T>> for &f64 where T: NumLike+From<f64> {
10440	type Output = Voltage<T>;
10441	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10442		Voltage{V: T::from(self.clone()) / rhs.per_V}
10443	}
10444}
10445/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10446impl<T> core::ops::Div<&InverseVoltage<T>> for f64 where T: NumLike+From<f64> {
10447	type Output = Voltage<T>;
10448	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10449		Voltage{V: T::from(self) / rhs.per_V.clone()}
10450	}
10451}
10452/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10453impl<T> core::ops::Div<&InverseVoltage<T>> for &f64 where T: NumLike+From<f64> {
10454	type Output = Voltage<T>;
10455	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10456		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10457	}
10458}
10459
10460// 1/InverseVoltage -> Voltage
10461/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10462impl<T> core::ops::Div<InverseVoltage<T>> for f32 where T: NumLike+From<f32> {
10463	type Output = Voltage<T>;
10464	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10465		Voltage{V: T::from(self) / rhs.per_V}
10466	}
10467}
10468/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10469impl<T> core::ops::Div<InverseVoltage<T>> for &f32 where T: NumLike+From<f32> {
10470	type Output = Voltage<T>;
10471	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10472		Voltage{V: T::from(self.clone()) / rhs.per_V}
10473	}
10474}
10475/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10476impl<T> core::ops::Div<&InverseVoltage<T>> for f32 where T: NumLike+From<f32> {
10477	type Output = Voltage<T>;
10478	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10479		Voltage{V: T::from(self) / rhs.per_V.clone()}
10480	}
10481}
10482/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10483impl<T> core::ops::Div<&InverseVoltage<T>> for &f32 where T: NumLike+From<f32> {
10484	type Output = Voltage<T>;
10485	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10486		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10487	}
10488}
10489
10490// 1/InverseVoltage -> Voltage
10491/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10492impl<T> core::ops::Div<InverseVoltage<T>> for i64 where T: NumLike+From<i64> {
10493	type Output = Voltage<T>;
10494	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10495		Voltage{V: T::from(self) / rhs.per_V}
10496	}
10497}
10498/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10499impl<T> core::ops::Div<InverseVoltage<T>> for &i64 where T: NumLike+From<i64> {
10500	type Output = Voltage<T>;
10501	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10502		Voltage{V: T::from(self.clone()) / rhs.per_V}
10503	}
10504}
10505/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10506impl<T> core::ops::Div<&InverseVoltage<T>> for i64 where T: NumLike+From<i64> {
10507	type Output = Voltage<T>;
10508	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10509		Voltage{V: T::from(self) / rhs.per_V.clone()}
10510	}
10511}
10512/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10513impl<T> core::ops::Div<&InverseVoltage<T>> for &i64 where T: NumLike+From<i64> {
10514	type Output = Voltage<T>;
10515	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10516		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10517	}
10518}
10519
10520// 1/InverseVoltage -> Voltage
10521/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10522impl<T> core::ops::Div<InverseVoltage<T>> for i32 where T: NumLike+From<i32> {
10523	type Output = Voltage<T>;
10524	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10525		Voltage{V: T::from(self) / rhs.per_V}
10526	}
10527}
10528/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10529impl<T> core::ops::Div<InverseVoltage<T>> for &i32 where T: NumLike+From<i32> {
10530	type Output = Voltage<T>;
10531	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10532		Voltage{V: T::from(self.clone()) / rhs.per_V}
10533	}
10534}
10535/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10536impl<T> core::ops::Div<&InverseVoltage<T>> for i32 where T: NumLike+From<i32> {
10537	type Output = Voltage<T>;
10538	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10539		Voltage{V: T::from(self) / rhs.per_V.clone()}
10540	}
10541}
10542/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10543impl<T> core::ops::Div<&InverseVoltage<T>> for &i32 where T: NumLike+From<i32> {
10544	type Output = Voltage<T>;
10545	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10546		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10547	}
10548}
10549
10550// 1/InverseVoltage -> Voltage
10551/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10552#[cfg(feature="num-bigfloat")]
10553impl<T> core::ops::Div<InverseVoltage<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
10554	type Output = Voltage<T>;
10555	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10556		Voltage{V: T::from(self) / rhs.per_V}
10557	}
10558}
10559/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10560#[cfg(feature="num-bigfloat")]
10561impl<T> core::ops::Div<InverseVoltage<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
10562	type Output = Voltage<T>;
10563	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10564		Voltage{V: T::from(self.clone()) / rhs.per_V}
10565	}
10566}
10567/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10568#[cfg(feature="num-bigfloat")]
10569impl<T> core::ops::Div<&InverseVoltage<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
10570	type Output = Voltage<T>;
10571	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10572		Voltage{V: T::from(self) / rhs.per_V.clone()}
10573	}
10574}
10575/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10576#[cfg(feature="num-bigfloat")]
10577impl<T> core::ops::Div<&InverseVoltage<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
10578	type Output = Voltage<T>;
10579	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10580		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10581	}
10582}
10583
10584// 1/InverseVoltage -> Voltage
10585/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10586#[cfg(feature="num-complex")]
10587impl<T> core::ops::Div<InverseVoltage<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
10588	type Output = Voltage<T>;
10589	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10590		Voltage{V: T::from(self) / rhs.per_V}
10591	}
10592}
10593/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10594#[cfg(feature="num-complex")]
10595impl<T> core::ops::Div<InverseVoltage<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
10596	type Output = Voltage<T>;
10597	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10598		Voltage{V: T::from(self.clone()) / rhs.per_V}
10599	}
10600}
10601/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10602#[cfg(feature="num-complex")]
10603impl<T> core::ops::Div<&InverseVoltage<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
10604	type Output = Voltage<T>;
10605	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10606		Voltage{V: T::from(self) / rhs.per_V.clone()}
10607	}
10608}
10609/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10610#[cfg(feature="num-complex")]
10611impl<T> core::ops::Div<&InverseVoltage<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
10612	type Output = Voltage<T>;
10613	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10614		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10615	}
10616}
10617
10618// 1/InverseVoltage -> Voltage
10619/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10620#[cfg(feature="num-complex")]
10621impl<T> core::ops::Div<InverseVoltage<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
10622	type Output = Voltage<T>;
10623	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10624		Voltage{V: T::from(self) / rhs.per_V}
10625	}
10626}
10627/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10628#[cfg(feature="num-complex")]
10629impl<T> core::ops::Div<InverseVoltage<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
10630	type Output = Voltage<T>;
10631	fn div(self, rhs: InverseVoltage<T>) -> Self::Output {
10632		Voltage{V: T::from(self.clone()) / rhs.per_V}
10633	}
10634}
10635/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10636#[cfg(feature="num-complex")]
10637impl<T> core::ops::Div<&InverseVoltage<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
10638	type Output = Voltage<T>;
10639	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10640		Voltage{V: T::from(self) / rhs.per_V.clone()}
10641	}
10642}
10643/// Dividing a scalar value by a InverseVoltage unit value returns a value of type Voltage
10644#[cfg(feature="num-complex")]
10645impl<T> core::ops::Div<&InverseVoltage<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
10646	type Output = Voltage<T>;
10647	fn div(self, rhs: &InverseVoltage<T>) -> Self::Output {
10648		Voltage{V: T::from(self.clone()) / rhs.per_V.clone()}
10649	}
10650}
10651
10652/// The luminous flux unit type, defined as lumens in SI units
10653#[derive(UnitStruct, Debug, Clone)]
10654#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
10655pub struct LuminousFlux<T: NumLike>{
10656	/// The value of this Luminous flux in lumens
10657	pub lm: T
10658}
10659
10660impl<T> LuminousFlux<T> where T: NumLike {
10661
10662	/// Returns the standard unit name of luminous flux: "lumens"
10663	pub fn unit_name() -> &'static str { "lumens" }
10664	
10665	/// Returns the abbreviated name or symbol of luminous flux: "lm" for lumens
10666	pub fn unit_symbol() -> &'static str { "lm" }
10667	
10668	/// Returns a new luminous flux value from the given number of lumens
10669	///
10670	/// # Arguments
10671	/// * `lm` - Any number-like type, representing a quantity of lumens
10672	pub fn from_lm(lm: T) -> Self { LuminousFlux{lm: lm} }
10673	
10674	/// Returns a copy of this luminous flux value in lumens
10675	pub fn to_lm(&self) -> T { self.lm.clone() }
10676
10677	/// Returns a new luminous flux value from the given number of lumens
10678	///
10679	/// # Arguments
10680	/// * `lumens` - Any number-like type, representing a quantity of lumens
10681	pub fn from_lumens(lumens: T) -> Self { LuminousFlux{lm: lumens} }
10682	
10683	/// Returns a copy of this luminous flux value in lumens
10684	pub fn to_lumens(&self) -> T { self.lm.clone() }
10685
10686}
10687
10688impl<T> fmt::Display for LuminousFlux<T> where T: NumLike {
10689	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10690		write!(f, "{} {}", &self.lm, Self::unit_symbol())
10691	}
10692}
10693
10694impl<T> LuminousFlux<T> where T: NumLike+From<f64> {
10695	
10696	/// Returns a copy of this luminous flux value in millilumens
10697	/// 
10698	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10699	pub fn to_mlm(&self) -> T {
10700		return self.lm.clone() * T::from(1000.0_f64);
10701	}
10702
10703	/// Returns a new luminous flux value from the given number of millilumens
10704	/// 
10705	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10706	///
10707	/// # Arguments
10708	/// * `mlm` - Any number-like type, representing a quantity of millilumens
10709	pub fn from_mlm(mlm: T) -> Self {
10710		LuminousFlux{lm: mlm * T::from(0.001_f64)}
10711	}
10712
10713	/// Returns a copy of this luminous flux value in microlumens
10714	/// 
10715	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10716	pub fn to_ulm(&self) -> T {
10717		return self.lm.clone() * T::from(1000000.0_f64);
10718	}
10719
10720	/// Returns a new luminous flux value from the given number of microlumens
10721	/// 
10722	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10723	///
10724	/// # Arguments
10725	/// * `ulm` - Any number-like type, representing a quantity of microlumens
10726	pub fn from_ulm(ulm: T) -> Self {
10727		LuminousFlux{lm: ulm * T::from(1e-06_f64)}
10728	}
10729
10730	/// Returns a copy of this luminous flux value in nanolumens
10731	/// 
10732	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10733	pub fn to_nlm(&self) -> T {
10734		return self.lm.clone() * T::from(1000000000.0_f64);
10735	}
10736
10737	/// Returns a new luminous flux value from the given number of nanolumens
10738	/// 
10739	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10740	///
10741	/// # Arguments
10742	/// * `nlm` - Any number-like type, representing a quantity of nanolumens
10743	pub fn from_nlm(nlm: T) -> Self {
10744		LuminousFlux{lm: nlm * T::from(1e-09_f64)}
10745	}
10746
10747	/// Returns a copy of this luminous flux value in kilolumens
10748	/// 
10749	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10750	pub fn to_klm(&self) -> T {
10751		return self.lm.clone() * T::from(0.001_f64);
10752	}
10753
10754	/// Returns a new luminous flux value from the given number of kilolumens
10755	/// 
10756	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10757	///
10758	/// # Arguments
10759	/// * `klm` - Any number-like type, representing a quantity of kilolumens
10760	pub fn from_klm(klm: T) -> Self {
10761		LuminousFlux{lm: klm * T::from(1000.0_f64)}
10762	}
10763
10764	/// Returns a copy of this luminous flux value in megalumens
10765	/// 
10766	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10767	pub fn to_Mlm(&self) -> T {
10768		return self.lm.clone() * T::from(1e-06_f64);
10769	}
10770
10771	/// Returns a new luminous flux value from the given number of megalumens
10772	/// 
10773	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10774	///
10775	/// # Arguments
10776	/// * `Mlm` - Any number-like type, representing a quantity of megalumens
10777	pub fn from_Mlm(Mlm: T) -> Self {
10778		LuminousFlux{lm: Mlm * T::from(1000000.0_f64)}
10779	}
10780
10781	/// Returns a copy of this luminous flux value in gigalumens
10782	/// 
10783	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10784	pub fn to_Glm(&self) -> T {
10785		return self.lm.clone() * T::from(1e-09_f64);
10786	}
10787
10788	/// Returns a new luminous flux value from the given number of gigalumens
10789	/// 
10790	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
10791	///
10792	/// # Arguments
10793	/// * `Glm` - Any number-like type, representing a quantity of gigalumens
10794	pub fn from_Glm(Glm: T) -> Self {
10795		LuminousFlux{lm: Glm * T::from(1000000000.0_f64)}
10796	}
10797
10798}
10799
10800
10801/// Multiplying a unit value by a scalar value returns a unit value
10802#[cfg(feature="num-bigfloat")]
10803impl core::ops::Mul<LuminousFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
10804	type Output = LuminousFlux<num_bigfloat::BigFloat>;
10805	fn mul(self, rhs: LuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
10806		LuminousFlux{lm: self * rhs.lm}
10807	}
10808}
10809/// Multiplying a unit value by a scalar value returns a unit value
10810#[cfg(feature="num-bigfloat")]
10811impl core::ops::Mul<LuminousFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
10812	type Output = LuminousFlux<num_bigfloat::BigFloat>;
10813	fn mul(self, rhs: LuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
10814		LuminousFlux{lm: self.clone() * rhs.lm}
10815	}
10816}
10817/// Multiplying a unit value by a scalar value returns a unit value
10818#[cfg(feature="num-bigfloat")]
10819impl core::ops::Mul<&LuminousFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
10820	type Output = LuminousFlux<num_bigfloat::BigFloat>;
10821	fn mul(self, rhs: &LuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
10822		LuminousFlux{lm: self * rhs.lm.clone()}
10823	}
10824}
10825/// Multiplying a unit value by a scalar value returns a unit value
10826#[cfg(feature="num-bigfloat")]
10827impl core::ops::Mul<&LuminousFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
10828	type Output = LuminousFlux<num_bigfloat::BigFloat>;
10829	fn mul(self, rhs: &LuminousFlux<num_bigfloat::BigFloat>) -> Self::Output {
10830		LuminousFlux{lm: self.clone() * rhs.lm.clone()}
10831	}
10832}
10833
10834/// Multiplying a unit value by a scalar value returns a unit value
10835#[cfg(feature="num-complex")]
10836impl core::ops::Mul<LuminousFlux<num_complex::Complex32>> for num_complex::Complex32 {
10837	type Output = LuminousFlux<num_complex::Complex32>;
10838	fn mul(self, rhs: LuminousFlux<num_complex::Complex32>) -> Self::Output {
10839		LuminousFlux{lm: self * rhs.lm}
10840	}
10841}
10842/// Multiplying a unit value by a scalar value returns a unit value
10843#[cfg(feature="num-complex")]
10844impl core::ops::Mul<LuminousFlux<num_complex::Complex32>> for &num_complex::Complex32 {
10845	type Output = LuminousFlux<num_complex::Complex32>;
10846	fn mul(self, rhs: LuminousFlux<num_complex::Complex32>) -> Self::Output {
10847		LuminousFlux{lm: self.clone() * rhs.lm}
10848	}
10849}
10850/// Multiplying a unit value by a scalar value returns a unit value
10851#[cfg(feature="num-complex")]
10852impl core::ops::Mul<&LuminousFlux<num_complex::Complex32>> for num_complex::Complex32 {
10853	type Output = LuminousFlux<num_complex::Complex32>;
10854	fn mul(self, rhs: &LuminousFlux<num_complex::Complex32>) -> Self::Output {
10855		LuminousFlux{lm: self * rhs.lm.clone()}
10856	}
10857}
10858/// Multiplying a unit value by a scalar value returns a unit value
10859#[cfg(feature="num-complex")]
10860impl core::ops::Mul<&LuminousFlux<num_complex::Complex32>> for &num_complex::Complex32 {
10861	type Output = LuminousFlux<num_complex::Complex32>;
10862	fn mul(self, rhs: &LuminousFlux<num_complex::Complex32>) -> Self::Output {
10863		LuminousFlux{lm: self.clone() * rhs.lm.clone()}
10864	}
10865}
10866
10867/// Multiplying a unit value by a scalar value returns a unit value
10868#[cfg(feature="num-complex")]
10869impl core::ops::Mul<LuminousFlux<num_complex::Complex64>> for num_complex::Complex64 {
10870	type Output = LuminousFlux<num_complex::Complex64>;
10871	fn mul(self, rhs: LuminousFlux<num_complex::Complex64>) -> Self::Output {
10872		LuminousFlux{lm: self * rhs.lm}
10873	}
10874}
10875/// Multiplying a unit value by a scalar value returns a unit value
10876#[cfg(feature="num-complex")]
10877impl core::ops::Mul<LuminousFlux<num_complex::Complex64>> for &num_complex::Complex64 {
10878	type Output = LuminousFlux<num_complex::Complex64>;
10879	fn mul(self, rhs: LuminousFlux<num_complex::Complex64>) -> Self::Output {
10880		LuminousFlux{lm: self.clone() * rhs.lm}
10881	}
10882}
10883/// Multiplying a unit value by a scalar value returns a unit value
10884#[cfg(feature="num-complex")]
10885impl core::ops::Mul<&LuminousFlux<num_complex::Complex64>> for num_complex::Complex64 {
10886	type Output = LuminousFlux<num_complex::Complex64>;
10887	fn mul(self, rhs: &LuminousFlux<num_complex::Complex64>) -> Self::Output {
10888		LuminousFlux{lm: self * rhs.lm.clone()}
10889	}
10890}
10891/// Multiplying a unit value by a scalar value returns a unit value
10892#[cfg(feature="num-complex")]
10893impl core::ops::Mul<&LuminousFlux<num_complex::Complex64>> for &num_complex::Complex64 {
10894	type Output = LuminousFlux<num_complex::Complex64>;
10895	fn mul(self, rhs: &LuminousFlux<num_complex::Complex64>) -> Self::Output {
10896		LuminousFlux{lm: self.clone() * rhs.lm.clone()}
10897	}
10898}
10899
10900
10901
10902
10903// LuminousFlux * InverseLuminosity -> SolidAngle
10904/// Multiplying a LuminousFlux by a InverseLuminosity returns a value of type SolidAngle
10905impl<T> core::ops::Mul<InverseLuminosity<T>> for LuminousFlux<T> where T: NumLike {
10906	type Output = SolidAngle<T>;
10907	fn mul(self, rhs: InverseLuminosity<T>) -> Self::Output {
10908		SolidAngle{sr: self.lm * rhs.per_cd}
10909	}
10910}
10911/// Multiplying a LuminousFlux by a InverseLuminosity returns a value of type SolidAngle
10912impl<T> core::ops::Mul<InverseLuminosity<T>> for &LuminousFlux<T> where T: NumLike {
10913	type Output = SolidAngle<T>;
10914	fn mul(self, rhs: InverseLuminosity<T>) -> Self::Output {
10915		SolidAngle{sr: self.lm.clone() * rhs.per_cd}
10916	}
10917}
10918/// Multiplying a LuminousFlux by a InverseLuminosity returns a value of type SolidAngle
10919impl<T> core::ops::Mul<&InverseLuminosity<T>> for LuminousFlux<T> where T: NumLike {
10920	type Output = SolidAngle<T>;
10921	fn mul(self, rhs: &InverseLuminosity<T>) -> Self::Output {
10922		SolidAngle{sr: self.lm * rhs.per_cd.clone()}
10923	}
10924}
10925/// Multiplying a LuminousFlux by a InverseLuminosity returns a value of type SolidAngle
10926impl<T> core::ops::Mul<&InverseLuminosity<T>> for &LuminousFlux<T> where T: NumLike {
10927	type Output = SolidAngle<T>;
10928	fn mul(self, rhs: &InverseLuminosity<T>) -> Self::Output {
10929		SolidAngle{sr: self.lm.clone() * rhs.per_cd.clone()}
10930	}
10931}
10932
10933// LuminousFlux / Luminosity -> SolidAngle
10934/// Dividing a LuminousFlux by a Luminosity returns a value of type SolidAngle
10935impl<T> core::ops::Div<Luminosity<T>> for LuminousFlux<T> where T: NumLike {
10936	type Output = SolidAngle<T>;
10937	fn div(self, rhs: Luminosity<T>) -> Self::Output {
10938		SolidAngle{sr: self.lm / rhs.cd}
10939	}
10940}
10941/// Dividing a LuminousFlux by a Luminosity returns a value of type SolidAngle
10942impl<T> core::ops::Div<Luminosity<T>> for &LuminousFlux<T> where T: NumLike {
10943	type Output = SolidAngle<T>;
10944	fn div(self, rhs: Luminosity<T>) -> Self::Output {
10945		SolidAngle{sr: self.lm.clone() / rhs.cd}
10946	}
10947}
10948/// Dividing a LuminousFlux by a Luminosity returns a value of type SolidAngle
10949impl<T> core::ops::Div<&Luminosity<T>> for LuminousFlux<T> where T: NumLike {
10950	type Output = SolidAngle<T>;
10951	fn div(self, rhs: &Luminosity<T>) -> Self::Output {
10952		SolidAngle{sr: self.lm / rhs.cd.clone()}
10953	}
10954}
10955/// Dividing a LuminousFlux by a Luminosity returns a value of type SolidAngle
10956impl<T> core::ops::Div<&Luminosity<T>> for &LuminousFlux<T> where T: NumLike {
10957	type Output = SolidAngle<T>;
10958	fn div(self, rhs: &Luminosity<T>) -> Self::Output {
10959		SolidAngle{sr: self.lm.clone() / rhs.cd.clone()}
10960	}
10961}
10962
10963// LuminousFlux * AreaPerLumen -> Area
10964/// Multiplying a LuminousFlux by a AreaPerLumen returns a value of type Area
10965impl<T> core::ops::Mul<AreaPerLumen<T>> for LuminousFlux<T> where T: NumLike {
10966	type Output = Area<T>;
10967	fn mul(self, rhs: AreaPerLumen<T>) -> Self::Output {
10968		Area{m2: self.lm * rhs.m2_per_lm}
10969	}
10970}
10971/// Multiplying a LuminousFlux by a AreaPerLumen returns a value of type Area
10972impl<T> core::ops::Mul<AreaPerLumen<T>> for &LuminousFlux<T> where T: NumLike {
10973	type Output = Area<T>;
10974	fn mul(self, rhs: AreaPerLumen<T>) -> Self::Output {
10975		Area{m2: self.lm.clone() * rhs.m2_per_lm}
10976	}
10977}
10978/// Multiplying a LuminousFlux by a AreaPerLumen returns a value of type Area
10979impl<T> core::ops::Mul<&AreaPerLumen<T>> for LuminousFlux<T> where T: NumLike {
10980	type Output = Area<T>;
10981	fn mul(self, rhs: &AreaPerLumen<T>) -> Self::Output {
10982		Area{m2: self.lm * rhs.m2_per_lm.clone()}
10983	}
10984}
10985/// Multiplying a LuminousFlux by a AreaPerLumen returns a value of type Area
10986impl<T> core::ops::Mul<&AreaPerLumen<T>> for &LuminousFlux<T> where T: NumLike {
10987	type Output = Area<T>;
10988	fn mul(self, rhs: &AreaPerLumen<T>) -> Self::Output {
10989		Area{m2: self.lm.clone() * rhs.m2_per_lm.clone()}
10990	}
10991}
10992
10993// LuminousFlux / Illuminance -> Area
10994/// Dividing a LuminousFlux by a Illuminance returns a value of type Area
10995impl<T> core::ops::Div<Illuminance<T>> for LuminousFlux<T> where T: NumLike {
10996	type Output = Area<T>;
10997	fn div(self, rhs: Illuminance<T>) -> Self::Output {
10998		Area{m2: self.lm / rhs.lux}
10999	}
11000}
11001/// Dividing a LuminousFlux by a Illuminance returns a value of type Area
11002impl<T> core::ops::Div<Illuminance<T>> for &LuminousFlux<T> where T: NumLike {
11003	type Output = Area<T>;
11004	fn div(self, rhs: Illuminance<T>) -> Self::Output {
11005		Area{m2: self.lm.clone() / rhs.lux}
11006	}
11007}
11008/// Dividing a LuminousFlux by a Illuminance returns a value of type Area
11009impl<T> core::ops::Div<&Illuminance<T>> for LuminousFlux<T> where T: NumLike {
11010	type Output = Area<T>;
11011	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
11012		Area{m2: self.lm / rhs.lux.clone()}
11013	}
11014}
11015/// Dividing a LuminousFlux by a Illuminance returns a value of type Area
11016impl<T> core::ops::Div<&Illuminance<T>> for &LuminousFlux<T> where T: NumLike {
11017	type Output = Area<T>;
11018	fn div(self, rhs: &Illuminance<T>) -> Self::Output {
11019		Area{m2: self.lm.clone() / rhs.lux.clone()}
11020	}
11021}
11022
11023// LuminousFlux / Area -> Illuminance
11024/// Dividing a LuminousFlux by a Area returns a value of type Illuminance
11025impl<T> core::ops::Div<Area<T>> for LuminousFlux<T> where T: NumLike {
11026	type Output = Illuminance<T>;
11027	fn div(self, rhs: Area<T>) -> Self::Output {
11028		Illuminance{lux: self.lm / rhs.m2}
11029	}
11030}
11031/// Dividing a LuminousFlux by a Area returns a value of type Illuminance
11032impl<T> core::ops::Div<Area<T>> for &LuminousFlux<T> where T: NumLike {
11033	type Output = Illuminance<T>;
11034	fn div(self, rhs: Area<T>) -> Self::Output {
11035		Illuminance{lux: self.lm.clone() / rhs.m2}
11036	}
11037}
11038/// Dividing a LuminousFlux by a Area returns a value of type Illuminance
11039impl<T> core::ops::Div<&Area<T>> for LuminousFlux<T> where T: NumLike {
11040	type Output = Illuminance<T>;
11041	fn div(self, rhs: &Area<T>) -> Self::Output {
11042		Illuminance{lux: self.lm / rhs.m2.clone()}
11043	}
11044}
11045/// Dividing a LuminousFlux by a Area returns a value of type Illuminance
11046impl<T> core::ops::Div<&Area<T>> for &LuminousFlux<T> where T: NumLike {
11047	type Output = Illuminance<T>;
11048	fn div(self, rhs: &Area<T>) -> Self::Output {
11049		Illuminance{lux: self.lm.clone() / rhs.m2.clone()}
11050	}
11051}
11052
11053// LuminousFlux * InverseArea -> Illuminance
11054/// Multiplying a LuminousFlux by a InverseArea returns a value of type Illuminance
11055impl<T> core::ops::Mul<InverseArea<T>> for LuminousFlux<T> where T: NumLike {
11056	type Output = Illuminance<T>;
11057	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
11058		Illuminance{lux: self.lm * rhs.per_m2}
11059	}
11060}
11061/// Multiplying a LuminousFlux by a InverseArea returns a value of type Illuminance
11062impl<T> core::ops::Mul<InverseArea<T>> for &LuminousFlux<T> where T: NumLike {
11063	type Output = Illuminance<T>;
11064	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
11065		Illuminance{lux: self.lm.clone() * rhs.per_m2}
11066	}
11067}
11068/// Multiplying a LuminousFlux by a InverseArea returns a value of type Illuminance
11069impl<T> core::ops::Mul<&InverseArea<T>> for LuminousFlux<T> where T: NumLike {
11070	type Output = Illuminance<T>;
11071	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
11072		Illuminance{lux: self.lm * rhs.per_m2.clone()}
11073	}
11074}
11075/// Multiplying a LuminousFlux by a InverseArea returns a value of type Illuminance
11076impl<T> core::ops::Mul<&InverseArea<T>> for &LuminousFlux<T> where T: NumLike {
11077	type Output = Illuminance<T>;
11078	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
11079		Illuminance{lux: self.lm.clone() * rhs.per_m2.clone()}
11080	}
11081}
11082
11083// LuminousFlux * InverseSolidAngle -> Luminosity
11084/// Multiplying a LuminousFlux by a InverseSolidAngle returns a value of type Luminosity
11085impl<T> core::ops::Mul<InverseSolidAngle<T>> for LuminousFlux<T> where T: NumLike {
11086	type Output = Luminosity<T>;
11087	fn mul(self, rhs: InverseSolidAngle<T>) -> Self::Output {
11088		Luminosity{cd: self.lm * rhs.per_sr}
11089	}
11090}
11091/// Multiplying a LuminousFlux by a InverseSolidAngle returns a value of type Luminosity
11092impl<T> core::ops::Mul<InverseSolidAngle<T>> for &LuminousFlux<T> where T: NumLike {
11093	type Output = Luminosity<T>;
11094	fn mul(self, rhs: InverseSolidAngle<T>) -> Self::Output {
11095		Luminosity{cd: self.lm.clone() * rhs.per_sr}
11096	}
11097}
11098/// Multiplying a LuminousFlux by a InverseSolidAngle returns a value of type Luminosity
11099impl<T> core::ops::Mul<&InverseSolidAngle<T>> for LuminousFlux<T> where T: NumLike {
11100	type Output = Luminosity<T>;
11101	fn mul(self, rhs: &InverseSolidAngle<T>) -> Self::Output {
11102		Luminosity{cd: self.lm * rhs.per_sr.clone()}
11103	}
11104}
11105/// Multiplying a LuminousFlux by a InverseSolidAngle returns a value of type Luminosity
11106impl<T> core::ops::Mul<&InverseSolidAngle<T>> for &LuminousFlux<T> where T: NumLike {
11107	type Output = Luminosity<T>;
11108	fn mul(self, rhs: &InverseSolidAngle<T>) -> Self::Output {
11109		Luminosity{cd: self.lm.clone() * rhs.per_sr.clone()}
11110	}
11111}
11112
11113// LuminousFlux / SolidAngle -> Luminosity
11114/// Dividing a LuminousFlux by a SolidAngle returns a value of type Luminosity
11115impl<T> core::ops::Div<SolidAngle<T>> for LuminousFlux<T> where T: NumLike {
11116	type Output = Luminosity<T>;
11117	fn div(self, rhs: SolidAngle<T>) -> Self::Output {
11118		Luminosity{cd: self.lm / rhs.sr}
11119	}
11120}
11121/// Dividing a LuminousFlux by a SolidAngle returns a value of type Luminosity
11122impl<T> core::ops::Div<SolidAngle<T>> for &LuminousFlux<T> where T: NumLike {
11123	type Output = Luminosity<T>;
11124	fn div(self, rhs: SolidAngle<T>) -> Self::Output {
11125		Luminosity{cd: self.lm.clone() / rhs.sr}
11126	}
11127}
11128/// Dividing a LuminousFlux by a SolidAngle returns a value of type Luminosity
11129impl<T> core::ops::Div<&SolidAngle<T>> for LuminousFlux<T> where T: NumLike {
11130	type Output = Luminosity<T>;
11131	fn div(self, rhs: &SolidAngle<T>) -> Self::Output {
11132		Luminosity{cd: self.lm / rhs.sr.clone()}
11133	}
11134}
11135/// Dividing a LuminousFlux by a SolidAngle returns a value of type Luminosity
11136impl<T> core::ops::Div<&SolidAngle<T>> for &LuminousFlux<T> where T: NumLike {
11137	type Output = Luminosity<T>;
11138	fn div(self, rhs: &SolidAngle<T>) -> Self::Output {
11139		Luminosity{cd: self.lm.clone() / rhs.sr.clone()}
11140	}
11141}
11142
11143// 1/LuminousFlux -> InverseLuminousFlux
11144/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11145impl<T> core::ops::Div<LuminousFlux<T>> for f64 where T: NumLike+From<f64> {
11146	type Output = InverseLuminousFlux<T>;
11147	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11148		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11149	}
11150}
11151/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11152impl<T> core::ops::Div<LuminousFlux<T>> for &f64 where T: NumLike+From<f64> {
11153	type Output = InverseLuminousFlux<T>;
11154	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11155		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11156	}
11157}
11158/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11159impl<T> core::ops::Div<&LuminousFlux<T>> for f64 where T: NumLike+From<f64> {
11160	type Output = InverseLuminousFlux<T>;
11161	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11162		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11163	}
11164}
11165/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11166impl<T> core::ops::Div<&LuminousFlux<T>> for &f64 where T: NumLike+From<f64> {
11167	type Output = InverseLuminousFlux<T>;
11168	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11169		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11170	}
11171}
11172
11173// 1/LuminousFlux -> InverseLuminousFlux
11174/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11175impl<T> core::ops::Div<LuminousFlux<T>> for f32 where T: NumLike+From<f32> {
11176	type Output = InverseLuminousFlux<T>;
11177	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11178		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11179	}
11180}
11181/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11182impl<T> core::ops::Div<LuminousFlux<T>> for &f32 where T: NumLike+From<f32> {
11183	type Output = InverseLuminousFlux<T>;
11184	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11185		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11186	}
11187}
11188/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11189impl<T> core::ops::Div<&LuminousFlux<T>> for f32 where T: NumLike+From<f32> {
11190	type Output = InverseLuminousFlux<T>;
11191	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11192		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11193	}
11194}
11195/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11196impl<T> core::ops::Div<&LuminousFlux<T>> for &f32 where T: NumLike+From<f32> {
11197	type Output = InverseLuminousFlux<T>;
11198	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11199		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11200	}
11201}
11202
11203// 1/LuminousFlux -> InverseLuminousFlux
11204/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11205impl<T> core::ops::Div<LuminousFlux<T>> for i64 where T: NumLike+From<i64> {
11206	type Output = InverseLuminousFlux<T>;
11207	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11208		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11209	}
11210}
11211/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11212impl<T> core::ops::Div<LuminousFlux<T>> for &i64 where T: NumLike+From<i64> {
11213	type Output = InverseLuminousFlux<T>;
11214	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11215		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11216	}
11217}
11218/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11219impl<T> core::ops::Div<&LuminousFlux<T>> for i64 where T: NumLike+From<i64> {
11220	type Output = InverseLuminousFlux<T>;
11221	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11222		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11223	}
11224}
11225/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11226impl<T> core::ops::Div<&LuminousFlux<T>> for &i64 where T: NumLike+From<i64> {
11227	type Output = InverseLuminousFlux<T>;
11228	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11229		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11230	}
11231}
11232
11233// 1/LuminousFlux -> InverseLuminousFlux
11234/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11235impl<T> core::ops::Div<LuminousFlux<T>> for i32 where T: NumLike+From<i32> {
11236	type Output = InverseLuminousFlux<T>;
11237	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11238		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11239	}
11240}
11241/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11242impl<T> core::ops::Div<LuminousFlux<T>> for &i32 where T: NumLike+From<i32> {
11243	type Output = InverseLuminousFlux<T>;
11244	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11245		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11246	}
11247}
11248/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11249impl<T> core::ops::Div<&LuminousFlux<T>> for i32 where T: NumLike+From<i32> {
11250	type Output = InverseLuminousFlux<T>;
11251	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11252		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11253	}
11254}
11255/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11256impl<T> core::ops::Div<&LuminousFlux<T>> for &i32 where T: NumLike+From<i32> {
11257	type Output = InverseLuminousFlux<T>;
11258	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11259		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11260	}
11261}
11262
11263// 1/LuminousFlux -> InverseLuminousFlux
11264/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11265#[cfg(feature="num-bigfloat")]
11266impl<T> core::ops::Div<LuminousFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
11267	type Output = InverseLuminousFlux<T>;
11268	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11269		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11270	}
11271}
11272/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11273#[cfg(feature="num-bigfloat")]
11274impl<T> core::ops::Div<LuminousFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
11275	type Output = InverseLuminousFlux<T>;
11276	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11277		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11278	}
11279}
11280/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11281#[cfg(feature="num-bigfloat")]
11282impl<T> core::ops::Div<&LuminousFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
11283	type Output = InverseLuminousFlux<T>;
11284	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11285		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11286	}
11287}
11288/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11289#[cfg(feature="num-bigfloat")]
11290impl<T> core::ops::Div<&LuminousFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
11291	type Output = InverseLuminousFlux<T>;
11292	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11293		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11294	}
11295}
11296
11297// 1/LuminousFlux -> InverseLuminousFlux
11298/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11299#[cfg(feature="num-complex")]
11300impl<T> core::ops::Div<LuminousFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
11301	type Output = InverseLuminousFlux<T>;
11302	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11303		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11304	}
11305}
11306/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11307#[cfg(feature="num-complex")]
11308impl<T> core::ops::Div<LuminousFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
11309	type Output = InverseLuminousFlux<T>;
11310	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11311		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11312	}
11313}
11314/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11315#[cfg(feature="num-complex")]
11316impl<T> core::ops::Div<&LuminousFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
11317	type Output = InverseLuminousFlux<T>;
11318	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11319		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11320	}
11321}
11322/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11323#[cfg(feature="num-complex")]
11324impl<T> core::ops::Div<&LuminousFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
11325	type Output = InverseLuminousFlux<T>;
11326	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11327		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11328	}
11329}
11330
11331// 1/LuminousFlux -> InverseLuminousFlux
11332/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11333#[cfg(feature="num-complex")]
11334impl<T> core::ops::Div<LuminousFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
11335	type Output = InverseLuminousFlux<T>;
11336	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11337		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm}
11338	}
11339}
11340/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11341#[cfg(feature="num-complex")]
11342impl<T> core::ops::Div<LuminousFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
11343	type Output = InverseLuminousFlux<T>;
11344	fn div(self, rhs: LuminousFlux<T>) -> Self::Output {
11345		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm}
11346	}
11347}
11348/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11349#[cfg(feature="num-complex")]
11350impl<T> core::ops::Div<&LuminousFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
11351	type Output = InverseLuminousFlux<T>;
11352	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11353		InverseLuminousFlux{per_lm: T::from(self) / rhs.lm.clone()}
11354	}
11355}
11356/// Dividing a scalar value by a LuminousFlux unit value returns a value of type InverseLuminousFlux
11357#[cfg(feature="num-complex")]
11358impl<T> core::ops::Div<&LuminousFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
11359	type Output = InverseLuminousFlux<T>;
11360	fn div(self, rhs: &LuminousFlux<T>) -> Self::Output {
11361		InverseLuminousFlux{per_lm: T::from(self.clone()) / rhs.lm.clone()}
11362	}
11363}
11364
11365/// The magnetic flux unit type, defined as webers in SI units
11366#[derive(UnitStruct, Debug, Clone)]
11367#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
11368pub struct MagneticFlux<T: NumLike>{
11369	/// The value of this Magnetic flux in webers
11370	pub Wb: T
11371}
11372
11373impl<T> MagneticFlux<T> where T: NumLike {
11374
11375	/// Returns the standard unit name of magnetic flux: "webers"
11376	pub fn unit_name() -> &'static str { "webers" }
11377	
11378	/// Returns the abbreviated name or symbol of magnetic flux: "Wb" for webers
11379	pub fn unit_symbol() -> &'static str { "Wb" }
11380	
11381	/// Returns a new magnetic flux value from the given number of webers
11382	///
11383	/// # Arguments
11384	/// * `Wb` - Any number-like type, representing a quantity of webers
11385	pub fn from_Wb(Wb: T) -> Self { MagneticFlux{Wb: Wb} }
11386	
11387	/// Returns a copy of this magnetic flux value in webers
11388	pub fn to_Wb(&self) -> T { self.Wb.clone() }
11389
11390	/// Returns a new magnetic flux value from the given number of webers
11391	///
11392	/// # Arguments
11393	/// * `webers` - Any number-like type, representing a quantity of webers
11394	pub fn from_webers(webers: T) -> Self { MagneticFlux{Wb: webers} }
11395	
11396	/// Returns a copy of this magnetic flux value in webers
11397	pub fn to_webers(&self) -> T { self.Wb.clone() }
11398
11399}
11400
11401impl<T> fmt::Display for MagneticFlux<T> where T: NumLike {
11402	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11403		write!(f, "{} {}", &self.Wb, Self::unit_symbol())
11404	}
11405}
11406
11407impl<T> MagneticFlux<T> where T: NumLike+From<f64> {
11408	
11409	/// Returns a copy of this magnetic flux value in milliwebers
11410	/// 
11411	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11412	pub fn to_mWb(&self) -> T {
11413		return self.Wb.clone() * T::from(1000.0_f64);
11414	}
11415
11416	/// Returns a new magnetic flux value from the given number of milliwebers
11417	/// 
11418	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11419	///
11420	/// # Arguments
11421	/// * `mWb` - Any number-like type, representing a quantity of milliwebers
11422	pub fn from_mWb(mWb: T) -> Self {
11423		MagneticFlux{Wb: mWb * T::from(0.001_f64)}
11424	}
11425
11426	/// Returns a copy of this magnetic flux value in microwebers
11427	/// 
11428	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11429	pub fn to_uWb(&self) -> T {
11430		return self.Wb.clone() * T::from(1000000.0_f64);
11431	}
11432
11433	/// Returns a new magnetic flux value from the given number of microwebers
11434	/// 
11435	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11436	///
11437	/// # Arguments
11438	/// * `uWb` - Any number-like type, representing a quantity of microwebers
11439	pub fn from_uWb(uWb: T) -> Self {
11440		MagneticFlux{Wb: uWb * T::from(1e-06_f64)}
11441	}
11442
11443	/// Returns a copy of this magnetic flux value in nanowebers
11444	/// 
11445	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11446	pub fn to_nWb(&self) -> T {
11447		return self.Wb.clone() * T::from(1000000000.0_f64);
11448	}
11449
11450	/// Returns a new magnetic flux value from the given number of nanowebers
11451	/// 
11452	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11453	///
11454	/// # Arguments
11455	/// * `nWb` - Any number-like type, representing a quantity of nanowebers
11456	pub fn from_nWb(nWb: T) -> Self {
11457		MagneticFlux{Wb: nWb * T::from(1e-09_f64)}
11458	}
11459
11460	/// Returns a copy of this magnetic flux value in kilowebers
11461	/// 
11462	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11463	pub fn to_kWb(&self) -> T {
11464		return self.Wb.clone() * T::from(0.001_f64);
11465	}
11466
11467	/// Returns a new magnetic flux value from the given number of kilowebers
11468	/// 
11469	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11470	///
11471	/// # Arguments
11472	/// * `kWb` - Any number-like type, representing a quantity of kilowebers
11473	pub fn from_kWb(kWb: T) -> Self {
11474		MagneticFlux{Wb: kWb * T::from(1000.0_f64)}
11475	}
11476
11477	/// Returns a copy of this magnetic flux value in megawebers
11478	/// 
11479	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11480	pub fn to_MWb(&self) -> T {
11481		return self.Wb.clone() * T::from(1e-06_f64);
11482	}
11483
11484	/// Returns a new magnetic flux value from the given number of megawebers
11485	/// 
11486	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11487	///
11488	/// # Arguments
11489	/// * `MWb` - Any number-like type, representing a quantity of megawebers
11490	pub fn from_MWb(MWb: T) -> Self {
11491		MagneticFlux{Wb: MWb * T::from(1000000.0_f64)}
11492	}
11493
11494	/// Returns a copy of this magnetic flux value in gigawebers
11495	/// 
11496	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11497	pub fn to_GWb(&self) -> T {
11498		return self.Wb.clone() * T::from(1e-09_f64);
11499	}
11500
11501	/// Returns a new magnetic flux value from the given number of gigawebers
11502	/// 
11503	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
11504	///
11505	/// # Arguments
11506	/// * `GWb` - Any number-like type, representing a quantity of gigawebers
11507	pub fn from_GWb(GWb: T) -> Self {
11508		MagneticFlux{Wb: GWb * T::from(1000000000.0_f64)}
11509	}
11510
11511}
11512
11513
11514/// Multiplying a unit value by a scalar value returns a unit value
11515#[cfg(feature="num-bigfloat")]
11516impl core::ops::Mul<MagneticFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
11517	type Output = MagneticFlux<num_bigfloat::BigFloat>;
11518	fn mul(self, rhs: MagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
11519		MagneticFlux{Wb: self * rhs.Wb}
11520	}
11521}
11522/// Multiplying a unit value by a scalar value returns a unit value
11523#[cfg(feature="num-bigfloat")]
11524impl core::ops::Mul<MagneticFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
11525	type Output = MagneticFlux<num_bigfloat::BigFloat>;
11526	fn mul(self, rhs: MagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
11527		MagneticFlux{Wb: self.clone() * rhs.Wb}
11528	}
11529}
11530/// Multiplying a unit value by a scalar value returns a unit value
11531#[cfg(feature="num-bigfloat")]
11532impl core::ops::Mul<&MagneticFlux<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
11533	type Output = MagneticFlux<num_bigfloat::BigFloat>;
11534	fn mul(self, rhs: &MagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
11535		MagneticFlux{Wb: self * rhs.Wb.clone()}
11536	}
11537}
11538/// Multiplying a unit value by a scalar value returns a unit value
11539#[cfg(feature="num-bigfloat")]
11540impl core::ops::Mul<&MagneticFlux<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
11541	type Output = MagneticFlux<num_bigfloat::BigFloat>;
11542	fn mul(self, rhs: &MagneticFlux<num_bigfloat::BigFloat>) -> Self::Output {
11543		MagneticFlux{Wb: self.clone() * rhs.Wb.clone()}
11544	}
11545}
11546
11547/// Multiplying a unit value by a scalar value returns a unit value
11548#[cfg(feature="num-complex")]
11549impl core::ops::Mul<MagneticFlux<num_complex::Complex32>> for num_complex::Complex32 {
11550	type Output = MagneticFlux<num_complex::Complex32>;
11551	fn mul(self, rhs: MagneticFlux<num_complex::Complex32>) -> Self::Output {
11552		MagneticFlux{Wb: self * rhs.Wb}
11553	}
11554}
11555/// Multiplying a unit value by a scalar value returns a unit value
11556#[cfg(feature="num-complex")]
11557impl core::ops::Mul<MagneticFlux<num_complex::Complex32>> for &num_complex::Complex32 {
11558	type Output = MagneticFlux<num_complex::Complex32>;
11559	fn mul(self, rhs: MagneticFlux<num_complex::Complex32>) -> Self::Output {
11560		MagneticFlux{Wb: self.clone() * rhs.Wb}
11561	}
11562}
11563/// Multiplying a unit value by a scalar value returns a unit value
11564#[cfg(feature="num-complex")]
11565impl core::ops::Mul<&MagneticFlux<num_complex::Complex32>> for num_complex::Complex32 {
11566	type Output = MagneticFlux<num_complex::Complex32>;
11567	fn mul(self, rhs: &MagneticFlux<num_complex::Complex32>) -> Self::Output {
11568		MagneticFlux{Wb: self * rhs.Wb.clone()}
11569	}
11570}
11571/// Multiplying a unit value by a scalar value returns a unit value
11572#[cfg(feature="num-complex")]
11573impl core::ops::Mul<&MagneticFlux<num_complex::Complex32>> for &num_complex::Complex32 {
11574	type Output = MagneticFlux<num_complex::Complex32>;
11575	fn mul(self, rhs: &MagneticFlux<num_complex::Complex32>) -> Self::Output {
11576		MagneticFlux{Wb: self.clone() * rhs.Wb.clone()}
11577	}
11578}
11579
11580/// Multiplying a unit value by a scalar value returns a unit value
11581#[cfg(feature="num-complex")]
11582impl core::ops::Mul<MagneticFlux<num_complex::Complex64>> for num_complex::Complex64 {
11583	type Output = MagneticFlux<num_complex::Complex64>;
11584	fn mul(self, rhs: MagneticFlux<num_complex::Complex64>) -> Self::Output {
11585		MagneticFlux{Wb: self * rhs.Wb}
11586	}
11587}
11588/// Multiplying a unit value by a scalar value returns a unit value
11589#[cfg(feature="num-complex")]
11590impl core::ops::Mul<MagneticFlux<num_complex::Complex64>> for &num_complex::Complex64 {
11591	type Output = MagneticFlux<num_complex::Complex64>;
11592	fn mul(self, rhs: MagneticFlux<num_complex::Complex64>) -> Self::Output {
11593		MagneticFlux{Wb: self.clone() * rhs.Wb}
11594	}
11595}
11596/// Multiplying a unit value by a scalar value returns a unit value
11597#[cfg(feature="num-complex")]
11598impl core::ops::Mul<&MagneticFlux<num_complex::Complex64>> for num_complex::Complex64 {
11599	type Output = MagneticFlux<num_complex::Complex64>;
11600	fn mul(self, rhs: &MagneticFlux<num_complex::Complex64>) -> Self::Output {
11601		MagneticFlux{Wb: self * rhs.Wb.clone()}
11602	}
11603}
11604/// Multiplying a unit value by a scalar value returns a unit value
11605#[cfg(feature="num-complex")]
11606impl core::ops::Mul<&MagneticFlux<num_complex::Complex64>> for &num_complex::Complex64 {
11607	type Output = MagneticFlux<num_complex::Complex64>;
11608	fn mul(self, rhs: &MagneticFlux<num_complex::Complex64>) -> Self::Output {
11609		MagneticFlux{Wb: self.clone() * rhs.Wb.clone()}
11610	}
11611}
11612
11613
11614
11615/// Converts a MagneticFlux into the equivalent [uom](https://crates.io/crates/uom) type [MagneticFlux](https://docs.rs/uom/0.34.0/uom/si/f32/type.MagneticFlux.html)
11616#[cfg(feature = "uom")]
11617impl<T> Into<uom::si::f32::MagneticFlux> for MagneticFlux<T> where T: NumLike+Into<f32> {
11618	fn into(self) -> uom::si::f32::MagneticFlux {
11619		uom::si::f32::MagneticFlux::new::<uom::si::magnetic_flux::weber>(self.Wb.into())
11620	}
11621}
11622
11623/// Creates a MagneticFlux from the equivalent [uom](https://crates.io/crates/uom) type [MagneticFlux](https://docs.rs/uom/0.34.0/uom/si/f32/type.MagneticFlux.html)
11624#[cfg(feature = "uom")]
11625impl<T> From<uom::si::f32::MagneticFlux> for MagneticFlux<T> where T: NumLike+From<f32> {
11626	fn from(src: uom::si::f32::MagneticFlux) -> Self {
11627		MagneticFlux{Wb: T::from(src.value)}
11628	}
11629}
11630
11631/// Converts a MagneticFlux into the equivalent [uom](https://crates.io/crates/uom) type [MagneticFlux](https://docs.rs/uom/0.34.0/uom/si/f64/type.MagneticFlux.html)
11632#[cfg(feature = "uom")]
11633impl<T> Into<uom::si::f64::MagneticFlux> for MagneticFlux<T> where T: NumLike+Into<f64> {
11634	fn into(self) -> uom::si::f64::MagneticFlux {
11635		uom::si::f64::MagneticFlux::new::<uom::si::magnetic_flux::weber>(self.Wb.into())
11636	}
11637}
11638
11639/// Creates a MagneticFlux from the equivalent [uom](https://crates.io/crates/uom) type [MagneticFlux](https://docs.rs/uom/0.34.0/uom/si/f64/type.MagneticFlux.html)
11640#[cfg(feature = "uom")]
11641impl<T> From<uom::si::f64::MagneticFlux> for MagneticFlux<T> where T: NumLike+From<f64> {
11642	fn from(src: uom::si::f64::MagneticFlux) -> Self {
11643		MagneticFlux{Wb: T::from(src.value)}
11644	}
11645}
11646
11647
11648// MagneticFlux * Current -> Energy
11649/// Multiplying a MagneticFlux by a Current returns a value of type Energy
11650impl<T> core::ops::Mul<Current<T>> for MagneticFlux<T> where T: NumLike {
11651	type Output = Energy<T>;
11652	fn mul(self, rhs: Current<T>) -> Self::Output {
11653		Energy{J: self.Wb * rhs.A}
11654	}
11655}
11656/// Multiplying a MagneticFlux by a Current returns a value of type Energy
11657impl<T> core::ops::Mul<Current<T>> for &MagneticFlux<T> where T: NumLike {
11658	type Output = Energy<T>;
11659	fn mul(self, rhs: Current<T>) -> Self::Output {
11660		Energy{J: self.Wb.clone() * rhs.A}
11661	}
11662}
11663/// Multiplying a MagneticFlux by a Current returns a value of type Energy
11664impl<T> core::ops::Mul<&Current<T>> for MagneticFlux<T> where T: NumLike {
11665	type Output = Energy<T>;
11666	fn mul(self, rhs: &Current<T>) -> Self::Output {
11667		Energy{J: self.Wb * rhs.A.clone()}
11668	}
11669}
11670/// Multiplying a MagneticFlux by a Current returns a value of type Energy
11671impl<T> core::ops::Mul<&Current<T>> for &MagneticFlux<T> where T: NumLike {
11672	type Output = Energy<T>;
11673	fn mul(self, rhs: &Current<T>) -> Self::Output {
11674		Energy{J: self.Wb.clone() * rhs.A.clone()}
11675	}
11676}
11677
11678// MagneticFlux / Current -> Inductance
11679/// Dividing a MagneticFlux by a Current returns a value of type Inductance
11680impl<T> core::ops::Div<Current<T>> for MagneticFlux<T> where T: NumLike {
11681	type Output = Inductance<T>;
11682	fn div(self, rhs: Current<T>) -> Self::Output {
11683		Inductance{H: self.Wb / rhs.A}
11684	}
11685}
11686/// Dividing a MagneticFlux by a Current returns a value of type Inductance
11687impl<T> core::ops::Div<Current<T>> for &MagneticFlux<T> where T: NumLike {
11688	type Output = Inductance<T>;
11689	fn div(self, rhs: Current<T>) -> Self::Output {
11690		Inductance{H: self.Wb.clone() / rhs.A}
11691	}
11692}
11693/// Dividing a MagneticFlux by a Current returns a value of type Inductance
11694impl<T> core::ops::Div<&Current<T>> for MagneticFlux<T> where T: NumLike {
11695	type Output = Inductance<T>;
11696	fn div(self, rhs: &Current<T>) -> Self::Output {
11697		Inductance{H: self.Wb / rhs.A.clone()}
11698	}
11699}
11700/// Dividing a MagneticFlux by a Current returns a value of type Inductance
11701impl<T> core::ops::Div<&Current<T>> for &MagneticFlux<T> where T: NumLike {
11702	type Output = Inductance<T>;
11703	fn div(self, rhs: &Current<T>) -> Self::Output {
11704		Inductance{H: self.Wb.clone() / rhs.A.clone()}
11705	}
11706}
11707
11708// MagneticFlux * InverseCurrent -> Inductance
11709/// Multiplying a MagneticFlux by a InverseCurrent returns a value of type Inductance
11710impl<T> core::ops::Mul<InverseCurrent<T>> for MagneticFlux<T> where T: NumLike {
11711	type Output = Inductance<T>;
11712	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
11713		Inductance{H: self.Wb * rhs.per_A}
11714	}
11715}
11716/// Multiplying a MagneticFlux by a InverseCurrent returns a value of type Inductance
11717impl<T> core::ops::Mul<InverseCurrent<T>> for &MagneticFlux<T> where T: NumLike {
11718	type Output = Inductance<T>;
11719	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
11720		Inductance{H: self.Wb.clone() * rhs.per_A}
11721	}
11722}
11723/// Multiplying a MagneticFlux by a InverseCurrent returns a value of type Inductance
11724impl<T> core::ops::Mul<&InverseCurrent<T>> for MagneticFlux<T> where T: NumLike {
11725	type Output = Inductance<T>;
11726	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
11727		Inductance{H: self.Wb * rhs.per_A.clone()}
11728	}
11729}
11730/// Multiplying a MagneticFlux by a InverseCurrent returns a value of type Inductance
11731impl<T> core::ops::Mul<&InverseCurrent<T>> for &MagneticFlux<T> where T: NumLike {
11732	type Output = Inductance<T>;
11733	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
11734		Inductance{H: self.Wb.clone() * rhs.per_A.clone()}
11735	}
11736}
11737
11738// MagneticFlux / InverseCurrent -> Energy
11739/// Dividing a MagneticFlux by a InverseCurrent returns a value of type Energy
11740impl<T> core::ops::Div<InverseCurrent<T>> for MagneticFlux<T> where T: NumLike {
11741	type Output = Energy<T>;
11742	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
11743		Energy{J: self.Wb / rhs.per_A}
11744	}
11745}
11746/// Dividing a MagneticFlux by a InverseCurrent returns a value of type Energy
11747impl<T> core::ops::Div<InverseCurrent<T>> for &MagneticFlux<T> where T: NumLike {
11748	type Output = Energy<T>;
11749	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
11750		Energy{J: self.Wb.clone() / rhs.per_A}
11751	}
11752}
11753/// Dividing a MagneticFlux by a InverseCurrent returns a value of type Energy
11754impl<T> core::ops::Div<&InverseCurrent<T>> for MagneticFlux<T> where T: NumLike {
11755	type Output = Energy<T>;
11756	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
11757		Energy{J: self.Wb / rhs.per_A.clone()}
11758	}
11759}
11760/// Dividing a MagneticFlux by a InverseCurrent returns a value of type Energy
11761impl<T> core::ops::Div<&InverseCurrent<T>> for &MagneticFlux<T> where T: NumLike {
11762	type Output = Energy<T>;
11763	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
11764		Energy{J: self.Wb.clone() / rhs.per_A.clone()}
11765	}
11766}
11767
11768// MagneticFlux / Time -> Voltage
11769/// Dividing a MagneticFlux by a Time returns a value of type Voltage
11770impl<T> core::ops::Div<Time<T>> for MagneticFlux<T> where T: NumLike {
11771	type Output = Voltage<T>;
11772	fn div(self, rhs: Time<T>) -> Self::Output {
11773		Voltage{V: self.Wb / rhs.s}
11774	}
11775}
11776/// Dividing a MagneticFlux by a Time returns a value of type Voltage
11777impl<T> core::ops::Div<Time<T>> for &MagneticFlux<T> where T: NumLike {
11778	type Output = Voltage<T>;
11779	fn div(self, rhs: Time<T>) -> Self::Output {
11780		Voltage{V: self.Wb.clone() / rhs.s}
11781	}
11782}
11783/// Dividing a MagneticFlux by a Time returns a value of type Voltage
11784impl<T> core::ops::Div<&Time<T>> for MagneticFlux<T> where T: NumLike {
11785	type Output = Voltage<T>;
11786	fn div(self, rhs: &Time<T>) -> Self::Output {
11787		Voltage{V: self.Wb / rhs.s.clone()}
11788	}
11789}
11790/// Dividing a MagneticFlux by a Time returns a value of type Voltage
11791impl<T> core::ops::Div<&Time<T>> for &MagneticFlux<T> where T: NumLike {
11792	type Output = Voltage<T>;
11793	fn div(self, rhs: &Time<T>) -> Self::Output {
11794		Voltage{V: self.Wb.clone() / rhs.s.clone()}
11795	}
11796}
11797
11798// MagneticFlux / Charge -> Resistance
11799/// Dividing a MagneticFlux by a Charge returns a value of type Resistance
11800impl<T> core::ops::Div<Charge<T>> for MagneticFlux<T> where T: NumLike {
11801	type Output = Resistance<T>;
11802	fn div(self, rhs: Charge<T>) -> Self::Output {
11803		Resistance{Ohm: self.Wb / rhs.C}
11804	}
11805}
11806/// Dividing a MagneticFlux by a Charge returns a value of type Resistance
11807impl<T> core::ops::Div<Charge<T>> for &MagneticFlux<T> where T: NumLike {
11808	type Output = Resistance<T>;
11809	fn div(self, rhs: Charge<T>) -> Self::Output {
11810		Resistance{Ohm: self.Wb.clone() / rhs.C}
11811	}
11812}
11813/// Dividing a MagneticFlux by a Charge returns a value of type Resistance
11814impl<T> core::ops::Div<&Charge<T>> for MagneticFlux<T> where T: NumLike {
11815	type Output = Resistance<T>;
11816	fn div(self, rhs: &Charge<T>) -> Self::Output {
11817		Resistance{Ohm: self.Wb / rhs.C.clone()}
11818	}
11819}
11820/// Dividing a MagneticFlux by a Charge returns a value of type Resistance
11821impl<T> core::ops::Div<&Charge<T>> for &MagneticFlux<T> where T: NumLike {
11822	type Output = Resistance<T>;
11823	fn div(self, rhs: &Charge<T>) -> Self::Output {
11824		Resistance{Ohm: self.Wb.clone() / rhs.C.clone()}
11825	}
11826}
11827
11828// MagneticFlux * Conductance -> Charge
11829/// Multiplying a MagneticFlux by a Conductance returns a value of type Charge
11830impl<T> core::ops::Mul<Conductance<T>> for MagneticFlux<T> where T: NumLike {
11831	type Output = Charge<T>;
11832	fn mul(self, rhs: Conductance<T>) -> Self::Output {
11833		Charge{C: self.Wb * rhs.S}
11834	}
11835}
11836/// Multiplying a MagneticFlux by a Conductance returns a value of type Charge
11837impl<T> core::ops::Mul<Conductance<T>> for &MagneticFlux<T> where T: NumLike {
11838	type Output = Charge<T>;
11839	fn mul(self, rhs: Conductance<T>) -> Self::Output {
11840		Charge{C: self.Wb.clone() * rhs.S}
11841	}
11842}
11843/// Multiplying a MagneticFlux by a Conductance returns a value of type Charge
11844impl<T> core::ops::Mul<&Conductance<T>> for MagneticFlux<T> where T: NumLike {
11845	type Output = Charge<T>;
11846	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
11847		Charge{C: self.Wb * rhs.S.clone()}
11848	}
11849}
11850/// Multiplying a MagneticFlux by a Conductance returns a value of type Charge
11851impl<T> core::ops::Mul<&Conductance<T>> for &MagneticFlux<T> where T: NumLike {
11852	type Output = Charge<T>;
11853	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
11854		Charge{C: self.Wb.clone() * rhs.S.clone()}
11855	}
11856}
11857
11858// MagneticFlux / Inductance -> Current
11859/// Dividing a MagneticFlux by a Inductance returns a value of type Current
11860impl<T> core::ops::Div<Inductance<T>> for MagneticFlux<T> where T: NumLike {
11861	type Output = Current<T>;
11862	fn div(self, rhs: Inductance<T>) -> Self::Output {
11863		Current{A: self.Wb / rhs.H}
11864	}
11865}
11866/// Dividing a MagneticFlux by a Inductance returns a value of type Current
11867impl<T> core::ops::Div<Inductance<T>> for &MagneticFlux<T> where T: NumLike {
11868	type Output = Current<T>;
11869	fn div(self, rhs: Inductance<T>) -> Self::Output {
11870		Current{A: self.Wb.clone() / rhs.H}
11871	}
11872}
11873/// Dividing a MagneticFlux by a Inductance returns a value of type Current
11874impl<T> core::ops::Div<&Inductance<T>> for MagneticFlux<T> where T: NumLike {
11875	type Output = Current<T>;
11876	fn div(self, rhs: &Inductance<T>) -> Self::Output {
11877		Current{A: self.Wb / rhs.H.clone()}
11878	}
11879}
11880/// Dividing a MagneticFlux by a Inductance returns a value of type Current
11881impl<T> core::ops::Div<&Inductance<T>> for &MagneticFlux<T> where T: NumLike {
11882	type Output = Current<T>;
11883	fn div(self, rhs: &Inductance<T>) -> Self::Output {
11884		Current{A: self.Wb.clone() / rhs.H.clone()}
11885	}
11886}
11887
11888// MagneticFlux * InverseCharge -> Resistance
11889/// Multiplying a MagneticFlux by a InverseCharge returns a value of type Resistance
11890impl<T> core::ops::Mul<InverseCharge<T>> for MagneticFlux<T> where T: NumLike {
11891	type Output = Resistance<T>;
11892	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
11893		Resistance{Ohm: self.Wb * rhs.per_C}
11894	}
11895}
11896/// Multiplying a MagneticFlux by a InverseCharge returns a value of type Resistance
11897impl<T> core::ops::Mul<InverseCharge<T>> for &MagneticFlux<T> where T: NumLike {
11898	type Output = Resistance<T>;
11899	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
11900		Resistance{Ohm: self.Wb.clone() * rhs.per_C}
11901	}
11902}
11903/// Multiplying a MagneticFlux by a InverseCharge returns a value of type Resistance
11904impl<T> core::ops::Mul<&InverseCharge<T>> for MagneticFlux<T> where T: NumLike {
11905	type Output = Resistance<T>;
11906	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
11907		Resistance{Ohm: self.Wb * rhs.per_C.clone()}
11908	}
11909}
11910/// Multiplying a MagneticFlux by a InverseCharge returns a value of type Resistance
11911impl<T> core::ops::Mul<&InverseCharge<T>> for &MagneticFlux<T> where T: NumLike {
11912	type Output = Resistance<T>;
11913	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
11914		Resistance{Ohm: self.Wb.clone() * rhs.per_C.clone()}
11915	}
11916}
11917
11918// MagneticFlux * InverseInductance -> Current
11919/// Multiplying a MagneticFlux by a InverseInductance returns a value of type Current
11920impl<T> core::ops::Mul<InverseInductance<T>> for MagneticFlux<T> where T: NumLike {
11921	type Output = Current<T>;
11922	fn mul(self, rhs: InverseInductance<T>) -> Self::Output {
11923		Current{A: self.Wb * rhs.per_H}
11924	}
11925}
11926/// Multiplying a MagneticFlux by a InverseInductance returns a value of type Current
11927impl<T> core::ops::Mul<InverseInductance<T>> for &MagneticFlux<T> where T: NumLike {
11928	type Output = Current<T>;
11929	fn mul(self, rhs: InverseInductance<T>) -> Self::Output {
11930		Current{A: self.Wb.clone() * rhs.per_H}
11931	}
11932}
11933/// Multiplying a MagneticFlux by a InverseInductance returns a value of type Current
11934impl<T> core::ops::Mul<&InverseInductance<T>> for MagneticFlux<T> where T: NumLike {
11935	type Output = Current<T>;
11936	fn mul(self, rhs: &InverseInductance<T>) -> Self::Output {
11937		Current{A: self.Wb * rhs.per_H.clone()}
11938	}
11939}
11940/// Multiplying a MagneticFlux by a InverseInductance returns a value of type Current
11941impl<T> core::ops::Mul<&InverseInductance<T>> for &MagneticFlux<T> where T: NumLike {
11942	type Output = Current<T>;
11943	fn mul(self, rhs: &InverseInductance<T>) -> Self::Output {
11944		Current{A: self.Wb.clone() * rhs.per_H.clone()}
11945	}
11946}
11947
11948// MagneticFlux * InverseMagneticFluxDensity -> Area
11949/// Multiplying a MagneticFlux by a InverseMagneticFluxDensity returns a value of type Area
11950impl<T> core::ops::Mul<InverseMagneticFluxDensity<T>> for MagneticFlux<T> where T: NumLike {
11951	type Output = Area<T>;
11952	fn mul(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
11953		Area{m2: self.Wb * rhs.m2_per_Wb}
11954	}
11955}
11956/// Multiplying a MagneticFlux by a InverseMagneticFluxDensity returns a value of type Area
11957impl<T> core::ops::Mul<InverseMagneticFluxDensity<T>> for &MagneticFlux<T> where T: NumLike {
11958	type Output = Area<T>;
11959	fn mul(self, rhs: InverseMagneticFluxDensity<T>) -> Self::Output {
11960		Area{m2: self.Wb.clone() * rhs.m2_per_Wb}
11961	}
11962}
11963/// Multiplying a MagneticFlux by a InverseMagneticFluxDensity returns a value of type Area
11964impl<T> core::ops::Mul<&InverseMagneticFluxDensity<T>> for MagneticFlux<T> where T: NumLike {
11965	type Output = Area<T>;
11966	fn mul(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
11967		Area{m2: self.Wb * rhs.m2_per_Wb.clone()}
11968	}
11969}
11970/// Multiplying a MagneticFlux by a InverseMagneticFluxDensity returns a value of type Area
11971impl<T> core::ops::Mul<&InverseMagneticFluxDensity<T>> for &MagneticFlux<T> where T: NumLike {
11972	type Output = Area<T>;
11973	fn mul(self, rhs: &InverseMagneticFluxDensity<T>) -> Self::Output {
11974		Area{m2: self.Wb.clone() * rhs.m2_per_Wb.clone()}
11975	}
11976}
11977
11978// MagneticFlux * InverseVoltage -> Time
11979/// Multiplying a MagneticFlux by a InverseVoltage returns a value of type Time
11980impl<T> core::ops::Mul<InverseVoltage<T>> for MagneticFlux<T> where T: NumLike {
11981	type Output = Time<T>;
11982	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
11983		Time{s: self.Wb * rhs.per_V}
11984	}
11985}
11986/// Multiplying a MagneticFlux by a InverseVoltage returns a value of type Time
11987impl<T> core::ops::Mul<InverseVoltage<T>> for &MagneticFlux<T> where T: NumLike {
11988	type Output = Time<T>;
11989	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
11990		Time{s: self.Wb.clone() * rhs.per_V}
11991	}
11992}
11993/// Multiplying a MagneticFlux by a InverseVoltage returns a value of type Time
11994impl<T> core::ops::Mul<&InverseVoltage<T>> for MagneticFlux<T> where T: NumLike {
11995	type Output = Time<T>;
11996	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
11997		Time{s: self.Wb * rhs.per_V.clone()}
11998	}
11999}
12000/// Multiplying a MagneticFlux by a InverseVoltage returns a value of type Time
12001impl<T> core::ops::Mul<&InverseVoltage<T>> for &MagneticFlux<T> where T: NumLike {
12002	type Output = Time<T>;
12003	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
12004		Time{s: self.Wb.clone() * rhs.per_V.clone()}
12005	}
12006}
12007
12008// MagneticFlux / MagneticFluxDensity -> Area
12009/// Dividing a MagneticFlux by a MagneticFluxDensity returns a value of type Area
12010impl<T> core::ops::Div<MagneticFluxDensity<T>> for MagneticFlux<T> where T: NumLike {
12011	type Output = Area<T>;
12012	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12013		Area{m2: self.Wb / rhs.T}
12014	}
12015}
12016/// Dividing a MagneticFlux by a MagneticFluxDensity returns a value of type Area
12017impl<T> core::ops::Div<MagneticFluxDensity<T>> for &MagneticFlux<T> where T: NumLike {
12018	type Output = Area<T>;
12019	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12020		Area{m2: self.Wb.clone() / rhs.T}
12021	}
12022}
12023/// Dividing a MagneticFlux by a MagneticFluxDensity returns a value of type Area
12024impl<T> core::ops::Div<&MagneticFluxDensity<T>> for MagneticFlux<T> where T: NumLike {
12025	type Output = Area<T>;
12026	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12027		Area{m2: self.Wb / rhs.T.clone()}
12028	}
12029}
12030/// Dividing a MagneticFlux by a MagneticFluxDensity returns a value of type Area
12031impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &MagneticFlux<T> where T: NumLike {
12032	type Output = Area<T>;
12033	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12034		Area{m2: self.Wb.clone() / rhs.T.clone()}
12035	}
12036}
12037
12038// MagneticFlux / Resistance -> Charge
12039/// Dividing a MagneticFlux by a Resistance returns a value of type Charge
12040impl<T> core::ops::Div<Resistance<T>> for MagneticFlux<T> where T: NumLike {
12041	type Output = Charge<T>;
12042	fn div(self, rhs: Resistance<T>) -> Self::Output {
12043		Charge{C: self.Wb / rhs.Ohm}
12044	}
12045}
12046/// Dividing a MagneticFlux by a Resistance returns a value of type Charge
12047impl<T> core::ops::Div<Resistance<T>> for &MagneticFlux<T> where T: NumLike {
12048	type Output = Charge<T>;
12049	fn div(self, rhs: Resistance<T>) -> Self::Output {
12050		Charge{C: self.Wb.clone() / rhs.Ohm}
12051	}
12052}
12053/// Dividing a MagneticFlux by a Resistance returns a value of type Charge
12054impl<T> core::ops::Div<&Resistance<T>> for MagneticFlux<T> where T: NumLike {
12055	type Output = Charge<T>;
12056	fn div(self, rhs: &Resistance<T>) -> Self::Output {
12057		Charge{C: self.Wb / rhs.Ohm.clone()}
12058	}
12059}
12060/// Dividing a MagneticFlux by a Resistance returns a value of type Charge
12061impl<T> core::ops::Div<&Resistance<T>> for &MagneticFlux<T> where T: NumLike {
12062	type Output = Charge<T>;
12063	fn div(self, rhs: &Resistance<T>) -> Self::Output {
12064		Charge{C: self.Wb.clone() / rhs.Ohm.clone()}
12065	}
12066}
12067
12068// MagneticFlux / Voltage -> Time
12069/// Dividing a MagneticFlux by a Voltage returns a value of type Time
12070impl<T> core::ops::Div<Voltage<T>> for MagneticFlux<T> where T: NumLike {
12071	type Output = Time<T>;
12072	fn div(self, rhs: Voltage<T>) -> Self::Output {
12073		Time{s: self.Wb / rhs.V}
12074	}
12075}
12076/// Dividing a MagneticFlux by a Voltage returns a value of type Time
12077impl<T> core::ops::Div<Voltage<T>> for &MagneticFlux<T> where T: NumLike {
12078	type Output = Time<T>;
12079	fn div(self, rhs: Voltage<T>) -> Self::Output {
12080		Time{s: self.Wb.clone() / rhs.V}
12081	}
12082}
12083/// Dividing a MagneticFlux by a Voltage returns a value of type Time
12084impl<T> core::ops::Div<&Voltage<T>> for MagneticFlux<T> where T: NumLike {
12085	type Output = Time<T>;
12086	fn div(self, rhs: &Voltage<T>) -> Self::Output {
12087		Time{s: self.Wb / rhs.V.clone()}
12088	}
12089}
12090/// Dividing a MagneticFlux by a Voltage returns a value of type Time
12091impl<T> core::ops::Div<&Voltage<T>> for &MagneticFlux<T> where T: NumLike {
12092	type Output = Time<T>;
12093	fn div(self, rhs: &Voltage<T>) -> Self::Output {
12094		Time{s: self.Wb.clone() / rhs.V.clone()}
12095	}
12096}
12097
12098// MagneticFlux / Area -> MagneticFluxDensity
12099/// Dividing a MagneticFlux by a Area returns a value of type MagneticFluxDensity
12100impl<T> core::ops::Div<Area<T>> for MagneticFlux<T> where T: NumLike {
12101	type Output = MagneticFluxDensity<T>;
12102	fn div(self, rhs: Area<T>) -> Self::Output {
12103		MagneticFluxDensity{T: self.Wb / rhs.m2}
12104	}
12105}
12106/// Dividing a MagneticFlux by a Area returns a value of type MagneticFluxDensity
12107impl<T> core::ops::Div<Area<T>> for &MagneticFlux<T> where T: NumLike {
12108	type Output = MagneticFluxDensity<T>;
12109	fn div(self, rhs: Area<T>) -> Self::Output {
12110		MagneticFluxDensity{T: self.Wb.clone() / rhs.m2}
12111	}
12112}
12113/// Dividing a MagneticFlux by a Area returns a value of type MagneticFluxDensity
12114impl<T> core::ops::Div<&Area<T>> for MagneticFlux<T> where T: NumLike {
12115	type Output = MagneticFluxDensity<T>;
12116	fn div(self, rhs: &Area<T>) -> Self::Output {
12117		MagneticFluxDensity{T: self.Wb / rhs.m2.clone()}
12118	}
12119}
12120/// Dividing a MagneticFlux by a Area returns a value of type MagneticFluxDensity
12121impl<T> core::ops::Div<&Area<T>> for &MagneticFlux<T> where T: NumLike {
12122	type Output = MagneticFluxDensity<T>;
12123	fn div(self, rhs: &Area<T>) -> Self::Output {
12124		MagneticFluxDensity{T: self.Wb.clone() / rhs.m2.clone()}
12125	}
12126}
12127
12128// MagneticFlux * InverseArea -> MagneticFluxDensity
12129/// Multiplying a MagneticFlux by a InverseArea returns a value of type MagneticFluxDensity
12130impl<T> core::ops::Mul<InverseArea<T>> for MagneticFlux<T> where T: NumLike {
12131	type Output = MagneticFluxDensity<T>;
12132	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
12133		MagneticFluxDensity{T: self.Wb * rhs.per_m2}
12134	}
12135}
12136/// Multiplying a MagneticFlux by a InverseArea returns a value of type MagneticFluxDensity
12137impl<T> core::ops::Mul<InverseArea<T>> for &MagneticFlux<T> where T: NumLike {
12138	type Output = MagneticFluxDensity<T>;
12139	fn mul(self, rhs: InverseArea<T>) -> Self::Output {
12140		MagneticFluxDensity{T: self.Wb.clone() * rhs.per_m2}
12141	}
12142}
12143/// Multiplying a MagneticFlux by a InverseArea returns a value of type MagneticFluxDensity
12144impl<T> core::ops::Mul<&InverseArea<T>> for MagneticFlux<T> where T: NumLike {
12145	type Output = MagneticFluxDensity<T>;
12146	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
12147		MagneticFluxDensity{T: self.Wb * rhs.per_m2.clone()}
12148	}
12149}
12150/// Multiplying a MagneticFlux by a InverseArea returns a value of type MagneticFluxDensity
12151impl<T> core::ops::Mul<&InverseArea<T>> for &MagneticFlux<T> where T: NumLike {
12152	type Output = MagneticFluxDensity<T>;
12153	fn mul(self, rhs: &InverseArea<T>) -> Self::Output {
12154		MagneticFluxDensity{T: self.Wb.clone() * rhs.per_m2.clone()}
12155	}
12156}
12157
12158// MagneticFlux / Energy -> InverseCurrent
12159/// Dividing a MagneticFlux by a Energy returns a value of type InverseCurrent
12160impl<T> core::ops::Div<Energy<T>> for MagneticFlux<T> where T: NumLike {
12161	type Output = InverseCurrent<T>;
12162	fn div(self, rhs: Energy<T>) -> Self::Output {
12163		InverseCurrent{per_A: self.Wb / rhs.J}
12164	}
12165}
12166/// Dividing a MagneticFlux by a Energy returns a value of type InverseCurrent
12167impl<T> core::ops::Div<Energy<T>> for &MagneticFlux<T> where T: NumLike {
12168	type Output = InverseCurrent<T>;
12169	fn div(self, rhs: Energy<T>) -> Self::Output {
12170		InverseCurrent{per_A: self.Wb.clone() / rhs.J}
12171	}
12172}
12173/// Dividing a MagneticFlux by a Energy returns a value of type InverseCurrent
12174impl<T> core::ops::Div<&Energy<T>> for MagneticFlux<T> where T: NumLike {
12175	type Output = InverseCurrent<T>;
12176	fn div(self, rhs: &Energy<T>) -> Self::Output {
12177		InverseCurrent{per_A: self.Wb / rhs.J.clone()}
12178	}
12179}
12180/// Dividing a MagneticFlux by a Energy returns a value of type InverseCurrent
12181impl<T> core::ops::Div<&Energy<T>> for &MagneticFlux<T> where T: NumLike {
12182	type Output = InverseCurrent<T>;
12183	fn div(self, rhs: &Energy<T>) -> Self::Output {
12184		InverseCurrent{per_A: self.Wb.clone() / rhs.J.clone()}
12185	}
12186}
12187
12188// MagneticFlux / Torque -> InverseCurrent
12189/// Dividing a MagneticFlux by a Torque returns a value of type InverseCurrent
12190impl<T> core::ops::Div<Torque<T>> for MagneticFlux<T> where T: NumLike {
12191	type Output = InverseCurrent<T>;
12192	fn div(self, rhs: Torque<T>) -> Self::Output {
12193		InverseCurrent{per_A: self.Wb / rhs.Nm}
12194	}
12195}
12196/// Dividing a MagneticFlux by a Torque returns a value of type InverseCurrent
12197impl<T> core::ops::Div<Torque<T>> for &MagneticFlux<T> where T: NumLike {
12198	type Output = InverseCurrent<T>;
12199	fn div(self, rhs: Torque<T>) -> Self::Output {
12200		InverseCurrent{per_A: self.Wb.clone() / rhs.Nm}
12201	}
12202}
12203/// Dividing a MagneticFlux by a Torque returns a value of type InverseCurrent
12204impl<T> core::ops::Div<&Torque<T>> for MagneticFlux<T> where T: NumLike {
12205	type Output = InverseCurrent<T>;
12206	fn div(self, rhs: &Torque<T>) -> Self::Output {
12207		InverseCurrent{per_A: self.Wb / rhs.Nm.clone()}
12208	}
12209}
12210/// Dividing a MagneticFlux by a Torque returns a value of type InverseCurrent
12211impl<T> core::ops::Div<&Torque<T>> for &MagneticFlux<T> where T: NumLike {
12212	type Output = InverseCurrent<T>;
12213	fn div(self, rhs: &Torque<T>) -> Self::Output {
12214		InverseCurrent{per_A: self.Wb.clone() / rhs.Nm.clone()}
12215	}
12216}
12217
12218// MagneticFlux * Frequency -> Voltage
12219/// Multiplying a MagneticFlux by a Frequency returns a value of type Voltage
12220impl<T> core::ops::Mul<Frequency<T>> for MagneticFlux<T> where T: NumLike {
12221	type Output = Voltage<T>;
12222	fn mul(self, rhs: Frequency<T>) -> Self::Output {
12223		Voltage{V: self.Wb * rhs.Hz}
12224	}
12225}
12226/// Multiplying a MagneticFlux by a Frequency returns a value of type Voltage
12227impl<T> core::ops::Mul<Frequency<T>> for &MagneticFlux<T> where T: NumLike {
12228	type Output = Voltage<T>;
12229	fn mul(self, rhs: Frequency<T>) -> Self::Output {
12230		Voltage{V: self.Wb.clone() * rhs.Hz}
12231	}
12232}
12233/// Multiplying a MagneticFlux by a Frequency returns a value of type Voltage
12234impl<T> core::ops::Mul<&Frequency<T>> for MagneticFlux<T> where T: NumLike {
12235	type Output = Voltage<T>;
12236	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
12237		Voltage{V: self.Wb * rhs.Hz.clone()}
12238	}
12239}
12240/// Multiplying a MagneticFlux by a Frequency returns a value of type Voltage
12241impl<T> core::ops::Mul<&Frequency<T>> for &MagneticFlux<T> where T: NumLike {
12242	type Output = Voltage<T>;
12243	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
12244		Voltage{V: self.Wb.clone() * rhs.Hz.clone()}
12245	}
12246}
12247
12248// MagneticFlux * InverseEnergy -> InverseCurrent
12249/// Multiplying a MagneticFlux by a InverseEnergy returns a value of type InverseCurrent
12250impl<T> core::ops::Mul<InverseEnergy<T>> for MagneticFlux<T> where T: NumLike {
12251	type Output = InverseCurrent<T>;
12252	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
12253		InverseCurrent{per_A: self.Wb * rhs.per_J}
12254	}
12255}
12256/// Multiplying a MagneticFlux by a InverseEnergy returns a value of type InverseCurrent
12257impl<T> core::ops::Mul<InverseEnergy<T>> for &MagneticFlux<T> where T: NumLike {
12258	type Output = InverseCurrent<T>;
12259	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
12260		InverseCurrent{per_A: self.Wb.clone() * rhs.per_J}
12261	}
12262}
12263/// Multiplying a MagneticFlux by a InverseEnergy returns a value of type InverseCurrent
12264impl<T> core::ops::Mul<&InverseEnergy<T>> for MagneticFlux<T> where T: NumLike {
12265	type Output = InverseCurrent<T>;
12266	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
12267		InverseCurrent{per_A: self.Wb * rhs.per_J.clone()}
12268	}
12269}
12270/// Multiplying a MagneticFlux by a InverseEnergy returns a value of type InverseCurrent
12271impl<T> core::ops::Mul<&InverseEnergy<T>> for &MagneticFlux<T> where T: NumLike {
12272	type Output = InverseCurrent<T>;
12273	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
12274		InverseCurrent{per_A: self.Wb.clone() * rhs.per_J.clone()}
12275	}
12276}
12277
12278// MagneticFlux * InverseTorque -> InverseCurrent
12279/// Multiplying a MagneticFlux by a InverseTorque returns a value of type InverseCurrent
12280impl<T> core::ops::Mul<InverseTorque<T>> for MagneticFlux<T> where T: NumLike {
12281	type Output = InverseCurrent<T>;
12282	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
12283		InverseCurrent{per_A: self.Wb * rhs.per_Nm}
12284	}
12285}
12286/// Multiplying a MagneticFlux by a InverseTorque returns a value of type InverseCurrent
12287impl<T> core::ops::Mul<InverseTorque<T>> for &MagneticFlux<T> where T: NumLike {
12288	type Output = InverseCurrent<T>;
12289	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
12290		InverseCurrent{per_A: self.Wb.clone() * rhs.per_Nm}
12291	}
12292}
12293/// Multiplying a MagneticFlux by a InverseTorque returns a value of type InverseCurrent
12294impl<T> core::ops::Mul<&InverseTorque<T>> for MagneticFlux<T> where T: NumLike {
12295	type Output = InverseCurrent<T>;
12296	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
12297		InverseCurrent{per_A: self.Wb * rhs.per_Nm.clone()}
12298	}
12299}
12300/// Multiplying a MagneticFlux by a InverseTorque returns a value of type InverseCurrent
12301impl<T> core::ops::Mul<&InverseTorque<T>> for &MagneticFlux<T> where T: NumLike {
12302	type Output = InverseCurrent<T>;
12303	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
12304		InverseCurrent{per_A: self.Wb.clone() * rhs.per_Nm.clone()}
12305	}
12306}
12307
12308// 1/MagneticFlux -> InverseMagneticFlux
12309/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12310impl<T> core::ops::Div<MagneticFlux<T>> for f64 where T: NumLike+From<f64> {
12311	type Output = InverseMagneticFlux<T>;
12312	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12313		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12314	}
12315}
12316/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12317impl<T> core::ops::Div<MagneticFlux<T>> for &f64 where T: NumLike+From<f64> {
12318	type Output = InverseMagneticFlux<T>;
12319	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12320		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12321	}
12322}
12323/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12324impl<T> core::ops::Div<&MagneticFlux<T>> for f64 where T: NumLike+From<f64> {
12325	type Output = InverseMagneticFlux<T>;
12326	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12327		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12328	}
12329}
12330/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12331impl<T> core::ops::Div<&MagneticFlux<T>> for &f64 where T: NumLike+From<f64> {
12332	type Output = InverseMagneticFlux<T>;
12333	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12334		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12335	}
12336}
12337
12338// 1/MagneticFlux -> InverseMagneticFlux
12339/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12340impl<T> core::ops::Div<MagneticFlux<T>> for f32 where T: NumLike+From<f32> {
12341	type Output = InverseMagneticFlux<T>;
12342	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12343		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12344	}
12345}
12346/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12347impl<T> core::ops::Div<MagneticFlux<T>> for &f32 where T: NumLike+From<f32> {
12348	type Output = InverseMagneticFlux<T>;
12349	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12350		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12351	}
12352}
12353/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12354impl<T> core::ops::Div<&MagneticFlux<T>> for f32 where T: NumLike+From<f32> {
12355	type Output = InverseMagneticFlux<T>;
12356	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12357		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12358	}
12359}
12360/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12361impl<T> core::ops::Div<&MagneticFlux<T>> for &f32 where T: NumLike+From<f32> {
12362	type Output = InverseMagneticFlux<T>;
12363	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12364		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12365	}
12366}
12367
12368// 1/MagneticFlux -> InverseMagneticFlux
12369/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12370impl<T> core::ops::Div<MagneticFlux<T>> for i64 where T: NumLike+From<i64> {
12371	type Output = InverseMagneticFlux<T>;
12372	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12373		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12374	}
12375}
12376/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12377impl<T> core::ops::Div<MagneticFlux<T>> for &i64 where T: NumLike+From<i64> {
12378	type Output = InverseMagneticFlux<T>;
12379	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12380		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12381	}
12382}
12383/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12384impl<T> core::ops::Div<&MagneticFlux<T>> for i64 where T: NumLike+From<i64> {
12385	type Output = InverseMagneticFlux<T>;
12386	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12387		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12388	}
12389}
12390/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12391impl<T> core::ops::Div<&MagneticFlux<T>> for &i64 where T: NumLike+From<i64> {
12392	type Output = InverseMagneticFlux<T>;
12393	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12394		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12395	}
12396}
12397
12398// 1/MagneticFlux -> InverseMagneticFlux
12399/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12400impl<T> core::ops::Div<MagneticFlux<T>> for i32 where T: NumLike+From<i32> {
12401	type Output = InverseMagneticFlux<T>;
12402	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12403		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12404	}
12405}
12406/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12407impl<T> core::ops::Div<MagneticFlux<T>> for &i32 where T: NumLike+From<i32> {
12408	type Output = InverseMagneticFlux<T>;
12409	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12410		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12411	}
12412}
12413/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12414impl<T> core::ops::Div<&MagneticFlux<T>> for i32 where T: NumLike+From<i32> {
12415	type Output = InverseMagneticFlux<T>;
12416	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12417		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12418	}
12419}
12420/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12421impl<T> core::ops::Div<&MagneticFlux<T>> for &i32 where T: NumLike+From<i32> {
12422	type Output = InverseMagneticFlux<T>;
12423	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12424		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12425	}
12426}
12427
12428// 1/MagneticFlux -> InverseMagneticFlux
12429/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12430#[cfg(feature="num-bigfloat")]
12431impl<T> core::ops::Div<MagneticFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
12432	type Output = InverseMagneticFlux<T>;
12433	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12434		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12435	}
12436}
12437/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12438#[cfg(feature="num-bigfloat")]
12439impl<T> core::ops::Div<MagneticFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
12440	type Output = InverseMagneticFlux<T>;
12441	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12442		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12443	}
12444}
12445/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12446#[cfg(feature="num-bigfloat")]
12447impl<T> core::ops::Div<&MagneticFlux<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
12448	type Output = InverseMagneticFlux<T>;
12449	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12450		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12451	}
12452}
12453/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12454#[cfg(feature="num-bigfloat")]
12455impl<T> core::ops::Div<&MagneticFlux<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
12456	type Output = InverseMagneticFlux<T>;
12457	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12458		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12459	}
12460}
12461
12462// 1/MagneticFlux -> InverseMagneticFlux
12463/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12464#[cfg(feature="num-complex")]
12465impl<T> core::ops::Div<MagneticFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
12466	type Output = InverseMagneticFlux<T>;
12467	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12468		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12469	}
12470}
12471/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12472#[cfg(feature="num-complex")]
12473impl<T> core::ops::Div<MagneticFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
12474	type Output = InverseMagneticFlux<T>;
12475	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12476		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12477	}
12478}
12479/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12480#[cfg(feature="num-complex")]
12481impl<T> core::ops::Div<&MagneticFlux<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
12482	type Output = InverseMagneticFlux<T>;
12483	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12484		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12485	}
12486}
12487/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12488#[cfg(feature="num-complex")]
12489impl<T> core::ops::Div<&MagneticFlux<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
12490	type Output = InverseMagneticFlux<T>;
12491	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12492		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12493	}
12494}
12495
12496// 1/MagneticFlux -> InverseMagneticFlux
12497/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12498#[cfg(feature="num-complex")]
12499impl<T> core::ops::Div<MagneticFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
12500	type Output = InverseMagneticFlux<T>;
12501	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12502		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb}
12503	}
12504}
12505/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12506#[cfg(feature="num-complex")]
12507impl<T> core::ops::Div<MagneticFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
12508	type Output = InverseMagneticFlux<T>;
12509	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12510		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb}
12511	}
12512}
12513/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12514#[cfg(feature="num-complex")]
12515impl<T> core::ops::Div<&MagneticFlux<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
12516	type Output = InverseMagneticFlux<T>;
12517	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12518		InverseMagneticFlux{per_Wb: T::from(self) / rhs.Wb.clone()}
12519	}
12520}
12521/// Dividing a scalar value by a MagneticFlux unit value returns a value of type InverseMagneticFlux
12522#[cfg(feature="num-complex")]
12523impl<T> core::ops::Div<&MagneticFlux<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
12524	type Output = InverseMagneticFlux<T>;
12525	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12526		InverseMagneticFlux{per_Wb: T::from(self.clone()) / rhs.Wb.clone()}
12527	}
12528}
12529
12530/// The magnetic flux density unit type, defined as teslas in SI units
12531#[derive(UnitStruct, Debug, Clone)]
12532#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
12533pub struct MagneticFluxDensity<T: NumLike>{
12534	/// The value of this Magnetic flux density in teslas
12535	pub T: T
12536}
12537
12538impl<T> MagneticFluxDensity<T> where T: NumLike {
12539
12540	/// Returns the standard unit name of magnetic flux density: "teslas"
12541	pub fn unit_name() -> &'static str { "teslas" }
12542	
12543	/// Returns the abbreviated name or symbol of magnetic flux density: "T" for teslas
12544	pub fn unit_symbol() -> &'static str { "T" }
12545	
12546	/// Returns a new magnetic flux density value from the given number of teslas
12547	///
12548	/// # Arguments
12549	/// * `T` - Any number-like type, representing a quantity of teslas
12550	pub fn from_T(T: T) -> Self { MagneticFluxDensity{T: T} }
12551	
12552	/// Returns a copy of this magnetic flux density value in teslas
12553	pub fn to_T(&self) -> T { self.T.clone() }
12554
12555	/// Returns a new magnetic flux density value from the given number of teslas
12556	///
12557	/// # Arguments
12558	/// * `teslas` - Any number-like type, representing a quantity of teslas
12559	pub fn from_teslas(teslas: T) -> Self { MagneticFluxDensity{T: teslas} }
12560	
12561	/// Returns a copy of this magnetic flux density value in teslas
12562	pub fn to_teslas(&self) -> T { self.T.clone() }
12563
12564}
12565
12566impl<T> fmt::Display for MagneticFluxDensity<T> where T: NumLike {
12567	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12568		write!(f, "{} {}", &self.T, Self::unit_symbol())
12569	}
12570}
12571
12572impl<T> MagneticFluxDensity<T> where T: NumLike+From<f64> {
12573	
12574	/// Returns a copy of this magnetic flux density value in milliteslas
12575	/// 
12576	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12577	pub fn to_mT(&self) -> T {
12578		return self.T.clone() * T::from(1000.0_f64);
12579	}
12580
12581	/// Returns a new magnetic flux density value from the given number of milliteslas
12582	/// 
12583	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12584	///
12585	/// # Arguments
12586	/// * `mT` - Any number-like type, representing a quantity of milliteslas
12587	pub fn from_mT(mT: T) -> Self {
12588		MagneticFluxDensity{T: mT * T::from(0.001_f64)}
12589	}
12590
12591	/// Returns a copy of this magnetic flux density value in microteslas
12592	/// 
12593	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12594	pub fn to_uT(&self) -> T {
12595		return self.T.clone() * T::from(1000000.0_f64);
12596	}
12597
12598	/// Returns a new magnetic flux density value from the given number of microteslas
12599	/// 
12600	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12601	///
12602	/// # Arguments
12603	/// * `uT` - Any number-like type, representing a quantity of microteslas
12604	pub fn from_uT(uT: T) -> Self {
12605		MagneticFluxDensity{T: uT * T::from(1e-06_f64)}
12606	}
12607
12608	/// Returns a copy of this magnetic flux density value in nanoteslas
12609	/// 
12610	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12611	pub fn to_nT(&self) -> T {
12612		return self.T.clone() * T::from(1000000000.0_f64);
12613	}
12614
12615	/// Returns a new magnetic flux density value from the given number of nanoteslas
12616	/// 
12617	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12618	///
12619	/// # Arguments
12620	/// * `nT` - Any number-like type, representing a quantity of nanoteslas
12621	pub fn from_nT(nT: T) -> Self {
12622		MagneticFluxDensity{T: nT * T::from(1e-09_f64)}
12623	}
12624
12625	/// Returns a copy of this magnetic flux density value in kiloteslas
12626	/// 
12627	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12628	pub fn to_kT(&self) -> T {
12629		return self.T.clone() * T::from(0.001_f64);
12630	}
12631
12632	/// Returns a new magnetic flux density value from the given number of kiloteslas
12633	/// 
12634	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12635	///
12636	/// # Arguments
12637	/// * `kT` - Any number-like type, representing a quantity of kiloteslas
12638	pub fn from_kT(kT: T) -> Self {
12639		MagneticFluxDensity{T: kT * T::from(1000.0_f64)}
12640	}
12641
12642	/// Returns a copy of this magnetic flux density value in megateslas
12643	/// 
12644	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12645	pub fn to_MT(&self) -> T {
12646		return self.T.clone() * T::from(1e-06_f64);
12647	}
12648
12649	/// Returns a new magnetic flux density value from the given number of megateslas
12650	/// 
12651	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12652	///
12653	/// # Arguments
12654	/// * `MT` - Any number-like type, representing a quantity of megateslas
12655	pub fn from_MT(MT: T) -> Self {
12656		MagneticFluxDensity{T: MT * T::from(1000000.0_f64)}
12657	}
12658
12659	/// Returns a copy of this magnetic flux density value in gigateslas
12660	/// 
12661	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12662	pub fn to_GT(&self) -> T {
12663		return self.T.clone() * T::from(1e-09_f64);
12664	}
12665
12666	/// Returns a new magnetic flux density value from the given number of gigateslas
12667	/// 
12668	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
12669	///
12670	/// # Arguments
12671	/// * `GT` - Any number-like type, representing a quantity of gigateslas
12672	pub fn from_GT(GT: T) -> Self {
12673		MagneticFluxDensity{T: GT * T::from(1000000000.0_f64)}
12674	}
12675
12676}
12677
12678
12679/// Multiplying a unit value by a scalar value returns a unit value
12680#[cfg(feature="num-bigfloat")]
12681impl core::ops::Mul<MagneticFluxDensity<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
12682	type Output = MagneticFluxDensity<num_bigfloat::BigFloat>;
12683	fn mul(self, rhs: MagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
12684		MagneticFluxDensity{T: self * rhs.T}
12685	}
12686}
12687/// Multiplying a unit value by a scalar value returns a unit value
12688#[cfg(feature="num-bigfloat")]
12689impl core::ops::Mul<MagneticFluxDensity<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
12690	type Output = MagneticFluxDensity<num_bigfloat::BigFloat>;
12691	fn mul(self, rhs: MagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
12692		MagneticFluxDensity{T: self.clone() * rhs.T}
12693	}
12694}
12695/// Multiplying a unit value by a scalar value returns a unit value
12696#[cfg(feature="num-bigfloat")]
12697impl core::ops::Mul<&MagneticFluxDensity<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
12698	type Output = MagneticFluxDensity<num_bigfloat::BigFloat>;
12699	fn mul(self, rhs: &MagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
12700		MagneticFluxDensity{T: self * rhs.T.clone()}
12701	}
12702}
12703/// Multiplying a unit value by a scalar value returns a unit value
12704#[cfg(feature="num-bigfloat")]
12705impl core::ops::Mul<&MagneticFluxDensity<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
12706	type Output = MagneticFluxDensity<num_bigfloat::BigFloat>;
12707	fn mul(self, rhs: &MagneticFluxDensity<num_bigfloat::BigFloat>) -> Self::Output {
12708		MagneticFluxDensity{T: self.clone() * rhs.T.clone()}
12709	}
12710}
12711
12712/// Multiplying a unit value by a scalar value returns a unit value
12713#[cfg(feature="num-complex")]
12714impl core::ops::Mul<MagneticFluxDensity<num_complex::Complex32>> for num_complex::Complex32 {
12715	type Output = MagneticFluxDensity<num_complex::Complex32>;
12716	fn mul(self, rhs: MagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
12717		MagneticFluxDensity{T: self * rhs.T}
12718	}
12719}
12720/// Multiplying a unit value by a scalar value returns a unit value
12721#[cfg(feature="num-complex")]
12722impl core::ops::Mul<MagneticFluxDensity<num_complex::Complex32>> for &num_complex::Complex32 {
12723	type Output = MagneticFluxDensity<num_complex::Complex32>;
12724	fn mul(self, rhs: MagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
12725		MagneticFluxDensity{T: self.clone() * rhs.T}
12726	}
12727}
12728/// Multiplying a unit value by a scalar value returns a unit value
12729#[cfg(feature="num-complex")]
12730impl core::ops::Mul<&MagneticFluxDensity<num_complex::Complex32>> for num_complex::Complex32 {
12731	type Output = MagneticFluxDensity<num_complex::Complex32>;
12732	fn mul(self, rhs: &MagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
12733		MagneticFluxDensity{T: self * rhs.T.clone()}
12734	}
12735}
12736/// Multiplying a unit value by a scalar value returns a unit value
12737#[cfg(feature="num-complex")]
12738impl core::ops::Mul<&MagneticFluxDensity<num_complex::Complex32>> for &num_complex::Complex32 {
12739	type Output = MagneticFluxDensity<num_complex::Complex32>;
12740	fn mul(self, rhs: &MagneticFluxDensity<num_complex::Complex32>) -> Self::Output {
12741		MagneticFluxDensity{T: self.clone() * rhs.T.clone()}
12742	}
12743}
12744
12745/// Multiplying a unit value by a scalar value returns a unit value
12746#[cfg(feature="num-complex")]
12747impl core::ops::Mul<MagneticFluxDensity<num_complex::Complex64>> for num_complex::Complex64 {
12748	type Output = MagneticFluxDensity<num_complex::Complex64>;
12749	fn mul(self, rhs: MagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
12750		MagneticFluxDensity{T: self * rhs.T}
12751	}
12752}
12753/// Multiplying a unit value by a scalar value returns a unit value
12754#[cfg(feature="num-complex")]
12755impl core::ops::Mul<MagneticFluxDensity<num_complex::Complex64>> for &num_complex::Complex64 {
12756	type Output = MagneticFluxDensity<num_complex::Complex64>;
12757	fn mul(self, rhs: MagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
12758		MagneticFluxDensity{T: self.clone() * rhs.T}
12759	}
12760}
12761/// Multiplying a unit value by a scalar value returns a unit value
12762#[cfg(feature="num-complex")]
12763impl core::ops::Mul<&MagneticFluxDensity<num_complex::Complex64>> for num_complex::Complex64 {
12764	type Output = MagneticFluxDensity<num_complex::Complex64>;
12765	fn mul(self, rhs: &MagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
12766		MagneticFluxDensity{T: self * rhs.T.clone()}
12767	}
12768}
12769/// Multiplying a unit value by a scalar value returns a unit value
12770#[cfg(feature="num-complex")]
12771impl core::ops::Mul<&MagneticFluxDensity<num_complex::Complex64>> for &num_complex::Complex64 {
12772	type Output = MagneticFluxDensity<num_complex::Complex64>;
12773	fn mul(self, rhs: &MagneticFluxDensity<num_complex::Complex64>) -> Self::Output {
12774		MagneticFluxDensity{T: self.clone() * rhs.T.clone()}
12775	}
12776}
12777
12778
12779
12780/// Converts a MagneticFluxDensity into the equivalent [uom](https://crates.io/crates/uom) type [MagneticFluxDensity](https://docs.rs/uom/0.34.0/uom/si/f32/type.MagneticFluxDensity.html)
12781#[cfg(feature = "uom")]
12782impl<T> Into<uom::si::f32::MagneticFluxDensity> for MagneticFluxDensity<T> where T: NumLike+Into<f32> {
12783	fn into(self) -> uom::si::f32::MagneticFluxDensity {
12784		uom::si::f32::MagneticFluxDensity::new::<uom::si::magnetic_flux_density::tesla>(self.T.into())
12785	}
12786}
12787
12788/// Creates a MagneticFluxDensity from the equivalent [uom](https://crates.io/crates/uom) type [MagneticFluxDensity](https://docs.rs/uom/0.34.0/uom/si/f32/type.MagneticFluxDensity.html)
12789#[cfg(feature = "uom")]
12790impl<T> From<uom::si::f32::MagneticFluxDensity> for MagneticFluxDensity<T> where T: NumLike+From<f32> {
12791	fn from(src: uom::si::f32::MagneticFluxDensity) -> Self {
12792		MagneticFluxDensity{T: T::from(src.value)}
12793	}
12794}
12795
12796/// Converts a MagneticFluxDensity into the equivalent [uom](https://crates.io/crates/uom) type [MagneticFluxDensity](https://docs.rs/uom/0.34.0/uom/si/f64/type.MagneticFluxDensity.html)
12797#[cfg(feature = "uom")]
12798impl<T> Into<uom::si::f64::MagneticFluxDensity> for MagneticFluxDensity<T> where T: NumLike+Into<f64> {
12799	fn into(self) -> uom::si::f64::MagneticFluxDensity {
12800		uom::si::f64::MagneticFluxDensity::new::<uom::si::magnetic_flux_density::tesla>(self.T.into())
12801	}
12802}
12803
12804/// Creates a MagneticFluxDensity from the equivalent [uom](https://crates.io/crates/uom) type [MagneticFluxDensity](https://docs.rs/uom/0.34.0/uom/si/f64/type.MagneticFluxDensity.html)
12805#[cfg(feature = "uom")]
12806impl<T> From<uom::si::f64::MagneticFluxDensity> for MagneticFluxDensity<T> where T: NumLike+From<f64> {
12807	fn from(src: uom::si::f64::MagneticFluxDensity) -> Self {
12808		MagneticFluxDensity{T: T::from(src.value)}
12809	}
12810}
12811
12812
12813// MagneticFluxDensity * InverseMagneticFlux -> InverseArea
12814/// Multiplying a MagneticFluxDensity by a InverseMagneticFlux returns a value of type InverseArea
12815impl<T> core::ops::Mul<InverseMagneticFlux<T>> for MagneticFluxDensity<T> where T: NumLike {
12816	type Output = InverseArea<T>;
12817	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
12818		InverseArea{per_m2: self.T * rhs.per_Wb}
12819	}
12820}
12821/// Multiplying a MagneticFluxDensity by a InverseMagneticFlux returns a value of type InverseArea
12822impl<T> core::ops::Mul<InverseMagneticFlux<T>> for &MagneticFluxDensity<T> where T: NumLike {
12823	type Output = InverseArea<T>;
12824	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
12825		InverseArea{per_m2: self.T.clone() * rhs.per_Wb}
12826	}
12827}
12828/// Multiplying a MagneticFluxDensity by a InverseMagneticFlux returns a value of type InverseArea
12829impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for MagneticFluxDensity<T> where T: NumLike {
12830	type Output = InverseArea<T>;
12831	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
12832		InverseArea{per_m2: self.T * rhs.per_Wb.clone()}
12833	}
12834}
12835/// Multiplying a MagneticFluxDensity by a InverseMagneticFlux returns a value of type InverseArea
12836impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for &MagneticFluxDensity<T> where T: NumLike {
12837	type Output = InverseArea<T>;
12838	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
12839		InverseArea{per_m2: self.T.clone() * rhs.per_Wb.clone()}
12840	}
12841}
12842
12843// MagneticFluxDensity / MagneticFlux -> InverseArea
12844/// Dividing a MagneticFluxDensity by a MagneticFlux returns a value of type InverseArea
12845impl<T> core::ops::Div<MagneticFlux<T>> for MagneticFluxDensity<T> where T: NumLike {
12846	type Output = InverseArea<T>;
12847	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12848		InverseArea{per_m2: self.T / rhs.Wb}
12849	}
12850}
12851/// Dividing a MagneticFluxDensity by a MagneticFlux returns a value of type InverseArea
12852impl<T> core::ops::Div<MagneticFlux<T>> for &MagneticFluxDensity<T> where T: NumLike {
12853	type Output = InverseArea<T>;
12854	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
12855		InverseArea{per_m2: self.T.clone() / rhs.Wb}
12856	}
12857}
12858/// Dividing a MagneticFluxDensity by a MagneticFlux returns a value of type InverseArea
12859impl<T> core::ops::Div<&MagneticFlux<T>> for MagneticFluxDensity<T> where T: NumLike {
12860	type Output = InverseArea<T>;
12861	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12862		InverseArea{per_m2: self.T / rhs.Wb.clone()}
12863	}
12864}
12865/// Dividing a MagneticFluxDensity by a MagneticFlux returns a value of type InverseArea
12866impl<T> core::ops::Div<&MagneticFlux<T>> for &MagneticFluxDensity<T> where T: NumLike {
12867	type Output = InverseArea<T>;
12868	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
12869		InverseArea{per_m2: self.T.clone() / rhs.Wb.clone()}
12870	}
12871}
12872
12873// MagneticFluxDensity * Area -> MagneticFlux
12874/// Multiplying a MagneticFluxDensity by a Area returns a value of type MagneticFlux
12875impl<T> core::ops::Mul<Area<T>> for MagneticFluxDensity<T> where T: NumLike {
12876	type Output = MagneticFlux<T>;
12877	fn mul(self, rhs: Area<T>) -> Self::Output {
12878		MagneticFlux{Wb: self.T * rhs.m2}
12879	}
12880}
12881/// Multiplying a MagneticFluxDensity by a Area returns a value of type MagneticFlux
12882impl<T> core::ops::Mul<Area<T>> for &MagneticFluxDensity<T> where T: NumLike {
12883	type Output = MagneticFlux<T>;
12884	fn mul(self, rhs: Area<T>) -> Self::Output {
12885		MagneticFlux{Wb: self.T.clone() * rhs.m2}
12886	}
12887}
12888/// Multiplying a MagneticFluxDensity by a Area returns a value of type MagneticFlux
12889impl<T> core::ops::Mul<&Area<T>> for MagneticFluxDensity<T> where T: NumLike {
12890	type Output = MagneticFlux<T>;
12891	fn mul(self, rhs: &Area<T>) -> Self::Output {
12892		MagneticFlux{Wb: self.T * rhs.m2.clone()}
12893	}
12894}
12895/// Multiplying a MagneticFluxDensity by a Area returns a value of type MagneticFlux
12896impl<T> core::ops::Mul<&Area<T>> for &MagneticFluxDensity<T> where T: NumLike {
12897	type Output = MagneticFlux<T>;
12898	fn mul(self, rhs: &Area<T>) -> Self::Output {
12899		MagneticFlux{Wb: self.T.clone() * rhs.m2.clone()}
12900	}
12901}
12902
12903// MagneticFluxDensity / InverseArea -> MagneticFlux
12904/// Dividing a MagneticFluxDensity by a InverseArea returns a value of type MagneticFlux
12905impl<T> core::ops::Div<InverseArea<T>> for MagneticFluxDensity<T> where T: NumLike {
12906	type Output = MagneticFlux<T>;
12907	fn div(self, rhs: InverseArea<T>) -> Self::Output {
12908		MagneticFlux{Wb: self.T / rhs.per_m2}
12909	}
12910}
12911/// Dividing a MagneticFluxDensity by a InverseArea returns a value of type MagneticFlux
12912impl<T> core::ops::Div<InverseArea<T>> for &MagneticFluxDensity<T> where T: NumLike {
12913	type Output = MagneticFlux<T>;
12914	fn div(self, rhs: InverseArea<T>) -> Self::Output {
12915		MagneticFlux{Wb: self.T.clone() / rhs.per_m2}
12916	}
12917}
12918/// Dividing a MagneticFluxDensity by a InverseArea returns a value of type MagneticFlux
12919impl<T> core::ops::Div<&InverseArea<T>> for MagneticFluxDensity<T> where T: NumLike {
12920	type Output = MagneticFlux<T>;
12921	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
12922		MagneticFlux{Wb: self.T / rhs.per_m2.clone()}
12923	}
12924}
12925/// Dividing a MagneticFluxDensity by a InverseArea returns a value of type MagneticFlux
12926impl<T> core::ops::Div<&InverseArea<T>> for &MagneticFluxDensity<T> where T: NumLike {
12927	type Output = MagneticFlux<T>;
12928	fn div(self, rhs: &InverseArea<T>) -> Self::Output {
12929		MagneticFlux{Wb: self.T.clone() / rhs.per_m2.clone()}
12930	}
12931}
12932
12933// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
12934/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12935impl<T> core::ops::Div<MagneticFluxDensity<T>> for f64 where T: NumLike+From<f64> {
12936	type Output = InverseMagneticFluxDensity<T>;
12937	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12938		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
12939	}
12940}
12941/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12942impl<T> core::ops::Div<MagneticFluxDensity<T>> for &f64 where T: NumLike+From<f64> {
12943	type Output = InverseMagneticFluxDensity<T>;
12944	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12945		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
12946	}
12947}
12948/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12949impl<T> core::ops::Div<&MagneticFluxDensity<T>> for f64 where T: NumLike+From<f64> {
12950	type Output = InverseMagneticFluxDensity<T>;
12951	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12952		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
12953	}
12954}
12955/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12956impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &f64 where T: NumLike+From<f64> {
12957	type Output = InverseMagneticFluxDensity<T>;
12958	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12959		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
12960	}
12961}
12962
12963// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
12964/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12965impl<T> core::ops::Div<MagneticFluxDensity<T>> for f32 where T: NumLike+From<f32> {
12966	type Output = InverseMagneticFluxDensity<T>;
12967	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12968		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
12969	}
12970}
12971/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12972impl<T> core::ops::Div<MagneticFluxDensity<T>> for &f32 where T: NumLike+From<f32> {
12973	type Output = InverseMagneticFluxDensity<T>;
12974	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12975		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
12976	}
12977}
12978/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12979impl<T> core::ops::Div<&MagneticFluxDensity<T>> for f32 where T: NumLike+From<f32> {
12980	type Output = InverseMagneticFluxDensity<T>;
12981	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12982		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
12983	}
12984}
12985/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12986impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &f32 where T: NumLike+From<f32> {
12987	type Output = InverseMagneticFluxDensity<T>;
12988	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
12989		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
12990	}
12991}
12992
12993// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
12994/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
12995impl<T> core::ops::Div<MagneticFluxDensity<T>> for i64 where T: NumLike+From<i64> {
12996	type Output = InverseMagneticFluxDensity<T>;
12997	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
12998		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
12999	}
13000}
13001/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13002impl<T> core::ops::Div<MagneticFluxDensity<T>> for &i64 where T: NumLike+From<i64> {
13003	type Output = InverseMagneticFluxDensity<T>;
13004	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13005		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
13006	}
13007}
13008/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13009impl<T> core::ops::Div<&MagneticFluxDensity<T>> for i64 where T: NumLike+From<i64> {
13010	type Output = InverseMagneticFluxDensity<T>;
13011	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13012		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
13013	}
13014}
13015/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13016impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &i64 where T: NumLike+From<i64> {
13017	type Output = InverseMagneticFluxDensity<T>;
13018	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13019		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
13020	}
13021}
13022
13023// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
13024/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13025impl<T> core::ops::Div<MagneticFluxDensity<T>> for i32 where T: NumLike+From<i32> {
13026	type Output = InverseMagneticFluxDensity<T>;
13027	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13028		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
13029	}
13030}
13031/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13032impl<T> core::ops::Div<MagneticFluxDensity<T>> for &i32 where T: NumLike+From<i32> {
13033	type Output = InverseMagneticFluxDensity<T>;
13034	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13035		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
13036	}
13037}
13038/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13039impl<T> core::ops::Div<&MagneticFluxDensity<T>> for i32 where T: NumLike+From<i32> {
13040	type Output = InverseMagneticFluxDensity<T>;
13041	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13042		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
13043	}
13044}
13045/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13046impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &i32 where T: NumLike+From<i32> {
13047	type Output = InverseMagneticFluxDensity<T>;
13048	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13049		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
13050	}
13051}
13052
13053// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
13054/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13055#[cfg(feature="num-bigfloat")]
13056impl<T> core::ops::Div<MagneticFluxDensity<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
13057	type Output = InverseMagneticFluxDensity<T>;
13058	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13059		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
13060	}
13061}
13062/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13063#[cfg(feature="num-bigfloat")]
13064impl<T> core::ops::Div<MagneticFluxDensity<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
13065	type Output = InverseMagneticFluxDensity<T>;
13066	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13067		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
13068	}
13069}
13070/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13071#[cfg(feature="num-bigfloat")]
13072impl<T> core::ops::Div<&MagneticFluxDensity<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
13073	type Output = InverseMagneticFluxDensity<T>;
13074	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13075		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
13076	}
13077}
13078/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13079#[cfg(feature="num-bigfloat")]
13080impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
13081	type Output = InverseMagneticFluxDensity<T>;
13082	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13083		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
13084	}
13085}
13086
13087// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
13088/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13089#[cfg(feature="num-complex")]
13090impl<T> core::ops::Div<MagneticFluxDensity<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
13091	type Output = InverseMagneticFluxDensity<T>;
13092	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13093		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
13094	}
13095}
13096/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13097#[cfg(feature="num-complex")]
13098impl<T> core::ops::Div<MagneticFluxDensity<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
13099	type Output = InverseMagneticFluxDensity<T>;
13100	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13101		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
13102	}
13103}
13104/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13105#[cfg(feature="num-complex")]
13106impl<T> core::ops::Div<&MagneticFluxDensity<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
13107	type Output = InverseMagneticFluxDensity<T>;
13108	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13109		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
13110	}
13111}
13112/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13113#[cfg(feature="num-complex")]
13114impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
13115	type Output = InverseMagneticFluxDensity<T>;
13116	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13117		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
13118	}
13119}
13120
13121// 1/MagneticFluxDensity -> InverseMagneticFluxDensity
13122/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13123#[cfg(feature="num-complex")]
13124impl<T> core::ops::Div<MagneticFluxDensity<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
13125	type Output = InverseMagneticFluxDensity<T>;
13126	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13127		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T}
13128	}
13129}
13130/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13131#[cfg(feature="num-complex")]
13132impl<T> core::ops::Div<MagneticFluxDensity<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
13133	type Output = InverseMagneticFluxDensity<T>;
13134	fn div(self, rhs: MagneticFluxDensity<T>) -> Self::Output {
13135		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T}
13136	}
13137}
13138/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13139#[cfg(feature="num-complex")]
13140impl<T> core::ops::Div<&MagneticFluxDensity<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
13141	type Output = InverseMagneticFluxDensity<T>;
13142	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13143		InverseMagneticFluxDensity{m2_per_Wb: T::from(self) / rhs.T.clone()}
13144	}
13145}
13146/// Dividing a scalar value by a MagneticFluxDensity unit value returns a value of type InverseMagneticFluxDensity
13147#[cfg(feature="num-complex")]
13148impl<T> core::ops::Div<&MagneticFluxDensity<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
13149	type Output = InverseMagneticFluxDensity<T>;
13150	fn div(self, rhs: &MagneticFluxDensity<T>) -> Self::Output {
13151		InverseMagneticFluxDensity{m2_per_Wb: T::from(self.clone()) / rhs.T.clone()}
13152	}
13153}
13154
13155/// The electrical resistance unit type, defined as ohms in SI units
13156#[derive(UnitStruct, Debug, Clone)]
13157#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
13158pub struct Resistance<T: NumLike>{
13159	/// The value of this Electrical resistance in ohms
13160	pub Ohm: T
13161}
13162
13163impl<T> Resistance<T> where T: NumLike {
13164
13165	/// Returns the standard unit name of electrical resistance: "ohms"
13166	pub fn unit_name() -> &'static str { "ohms" }
13167	
13168	/// Returns the abbreviated name or symbol of electrical resistance: "Ohm" for ohms
13169	pub fn unit_symbol() -> &'static str { "Ohm" }
13170	
13171	/// Returns a new electrical resistance value from the given number of ohms
13172	///
13173	/// # Arguments
13174	/// * `Ohm` - Any number-like type, representing a quantity of ohms
13175	pub fn from_Ohm(Ohm: T) -> Self { Resistance{Ohm: Ohm} }
13176	
13177	/// Returns a copy of this electrical resistance value in ohms
13178	pub fn to_Ohm(&self) -> T { self.Ohm.clone() }
13179
13180	/// Returns a new electrical resistance value from the given number of ohms
13181	///
13182	/// # Arguments
13183	/// * `ohms` - Any number-like type, representing a quantity of ohms
13184	pub fn from_ohms(ohms: T) -> Self { Resistance{Ohm: ohms} }
13185	
13186	/// Returns a copy of this electrical resistance value in ohms
13187	pub fn to_ohms(&self) -> T { self.Ohm.clone() }
13188
13189}
13190
13191impl<T> fmt::Display for Resistance<T> where T: NumLike {
13192	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13193		write!(f, "{} {}", &self.Ohm, Self::unit_symbol())
13194	}
13195}
13196
13197impl<T> Resistance<T> where T: NumLike+From<f64> {
13198	
13199	/// Returns a copy of this electrical resistance value in milliohms
13200	/// 
13201	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13202	pub fn to_mOhm(&self) -> T {
13203		return self.Ohm.clone() * T::from(1000.0_f64);
13204	}
13205
13206	/// Returns a new electrical resistance value from the given number of milliohms
13207	/// 
13208	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13209	///
13210	/// # Arguments
13211	/// * `mOhm` - Any number-like type, representing a quantity of milliohms
13212	pub fn from_mOhm(mOhm: T) -> Self {
13213		Resistance{Ohm: mOhm * T::from(0.001_f64)}
13214	}
13215
13216	/// Returns a copy of this electrical resistance value in microohms
13217	/// 
13218	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13219	pub fn to_uOhm(&self) -> T {
13220		return self.Ohm.clone() * T::from(1000000.0_f64);
13221	}
13222
13223	/// Returns a new electrical resistance value from the given number of microohms
13224	/// 
13225	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13226	///
13227	/// # Arguments
13228	/// * `uOhm` - Any number-like type, representing a quantity of microohms
13229	pub fn from_uOhm(uOhm: T) -> Self {
13230		Resistance{Ohm: uOhm * T::from(1e-06_f64)}
13231	}
13232
13233	/// Returns a copy of this electrical resistance value in nanoohms
13234	/// 
13235	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13236	pub fn to_nOhm(&self) -> T {
13237		return self.Ohm.clone() * T::from(1000000000.0_f64);
13238	}
13239
13240	/// Returns a new electrical resistance value from the given number of nanoohms
13241	/// 
13242	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13243	///
13244	/// # Arguments
13245	/// * `nOhm` - Any number-like type, representing a quantity of nanoohms
13246	pub fn from_nOhm(nOhm: T) -> Self {
13247		Resistance{Ohm: nOhm * T::from(1e-09_f64)}
13248	}
13249
13250	/// Returns a copy of this electrical resistance value in kiloohms
13251	/// 
13252	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13253	pub fn to_kOhm(&self) -> T {
13254		return self.Ohm.clone() * T::from(0.001_f64);
13255	}
13256
13257	/// Returns a new electrical resistance value from the given number of kiloohms
13258	/// 
13259	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13260	///
13261	/// # Arguments
13262	/// * `kOhm` - Any number-like type, representing a quantity of kiloohms
13263	pub fn from_kOhm(kOhm: T) -> Self {
13264		Resistance{Ohm: kOhm * T::from(1000.0_f64)}
13265	}
13266
13267	/// Returns a copy of this electrical resistance value in megaohms
13268	/// 
13269	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13270	pub fn to_MOhm(&self) -> T {
13271		return self.Ohm.clone() * T::from(1e-06_f64);
13272	}
13273
13274	/// Returns a new electrical resistance value from the given number of megaohms
13275	/// 
13276	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13277	///
13278	/// # Arguments
13279	/// * `MOhm` - Any number-like type, representing a quantity of megaohms
13280	pub fn from_MOhm(MOhm: T) -> Self {
13281		Resistance{Ohm: MOhm * T::from(1000000.0_f64)}
13282	}
13283
13284	/// Returns a copy of this electrical resistance value in gigaohms
13285	/// 
13286	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13287	pub fn to_GOhm(&self) -> T {
13288		return self.Ohm.clone() * T::from(1e-09_f64);
13289	}
13290
13291	/// Returns a new electrical resistance value from the given number of gigaohms
13292	/// 
13293	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
13294	///
13295	/// # Arguments
13296	/// * `GOhm` - Any number-like type, representing a quantity of gigaohms
13297	pub fn from_GOhm(GOhm: T) -> Self {
13298		Resistance{Ohm: GOhm * T::from(1000000000.0_f64)}
13299	}
13300
13301}
13302
13303
13304/// Multiplying a unit value by a scalar value returns a unit value
13305#[cfg(feature="num-bigfloat")]
13306impl core::ops::Mul<Resistance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
13307	type Output = Resistance<num_bigfloat::BigFloat>;
13308	fn mul(self, rhs: Resistance<num_bigfloat::BigFloat>) -> Self::Output {
13309		Resistance{Ohm: self * rhs.Ohm}
13310	}
13311}
13312/// Multiplying a unit value by a scalar value returns a unit value
13313#[cfg(feature="num-bigfloat")]
13314impl core::ops::Mul<Resistance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
13315	type Output = Resistance<num_bigfloat::BigFloat>;
13316	fn mul(self, rhs: Resistance<num_bigfloat::BigFloat>) -> Self::Output {
13317		Resistance{Ohm: self.clone() * rhs.Ohm}
13318	}
13319}
13320/// Multiplying a unit value by a scalar value returns a unit value
13321#[cfg(feature="num-bigfloat")]
13322impl core::ops::Mul<&Resistance<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
13323	type Output = Resistance<num_bigfloat::BigFloat>;
13324	fn mul(self, rhs: &Resistance<num_bigfloat::BigFloat>) -> Self::Output {
13325		Resistance{Ohm: self * rhs.Ohm.clone()}
13326	}
13327}
13328/// Multiplying a unit value by a scalar value returns a unit value
13329#[cfg(feature="num-bigfloat")]
13330impl core::ops::Mul<&Resistance<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
13331	type Output = Resistance<num_bigfloat::BigFloat>;
13332	fn mul(self, rhs: &Resistance<num_bigfloat::BigFloat>) -> Self::Output {
13333		Resistance{Ohm: self.clone() * rhs.Ohm.clone()}
13334	}
13335}
13336
13337/// Multiplying a unit value by a scalar value returns a unit value
13338#[cfg(feature="num-complex")]
13339impl core::ops::Mul<Resistance<num_complex::Complex32>> for num_complex::Complex32 {
13340	type Output = Resistance<num_complex::Complex32>;
13341	fn mul(self, rhs: Resistance<num_complex::Complex32>) -> Self::Output {
13342		Resistance{Ohm: self * rhs.Ohm}
13343	}
13344}
13345/// Multiplying a unit value by a scalar value returns a unit value
13346#[cfg(feature="num-complex")]
13347impl core::ops::Mul<Resistance<num_complex::Complex32>> for &num_complex::Complex32 {
13348	type Output = Resistance<num_complex::Complex32>;
13349	fn mul(self, rhs: Resistance<num_complex::Complex32>) -> Self::Output {
13350		Resistance{Ohm: self.clone() * rhs.Ohm}
13351	}
13352}
13353/// Multiplying a unit value by a scalar value returns a unit value
13354#[cfg(feature="num-complex")]
13355impl core::ops::Mul<&Resistance<num_complex::Complex32>> for num_complex::Complex32 {
13356	type Output = Resistance<num_complex::Complex32>;
13357	fn mul(self, rhs: &Resistance<num_complex::Complex32>) -> Self::Output {
13358		Resistance{Ohm: self * rhs.Ohm.clone()}
13359	}
13360}
13361/// Multiplying a unit value by a scalar value returns a unit value
13362#[cfg(feature="num-complex")]
13363impl core::ops::Mul<&Resistance<num_complex::Complex32>> for &num_complex::Complex32 {
13364	type Output = Resistance<num_complex::Complex32>;
13365	fn mul(self, rhs: &Resistance<num_complex::Complex32>) -> Self::Output {
13366		Resistance{Ohm: self.clone() * rhs.Ohm.clone()}
13367	}
13368}
13369
13370/// Multiplying a unit value by a scalar value returns a unit value
13371#[cfg(feature="num-complex")]
13372impl core::ops::Mul<Resistance<num_complex::Complex64>> for num_complex::Complex64 {
13373	type Output = Resistance<num_complex::Complex64>;
13374	fn mul(self, rhs: Resistance<num_complex::Complex64>) -> Self::Output {
13375		Resistance{Ohm: self * rhs.Ohm}
13376	}
13377}
13378/// Multiplying a unit value by a scalar value returns a unit value
13379#[cfg(feature="num-complex")]
13380impl core::ops::Mul<Resistance<num_complex::Complex64>> for &num_complex::Complex64 {
13381	type Output = Resistance<num_complex::Complex64>;
13382	fn mul(self, rhs: Resistance<num_complex::Complex64>) -> Self::Output {
13383		Resistance{Ohm: self.clone() * rhs.Ohm}
13384	}
13385}
13386/// Multiplying a unit value by a scalar value returns a unit value
13387#[cfg(feature="num-complex")]
13388impl core::ops::Mul<&Resistance<num_complex::Complex64>> for num_complex::Complex64 {
13389	type Output = Resistance<num_complex::Complex64>;
13390	fn mul(self, rhs: &Resistance<num_complex::Complex64>) -> Self::Output {
13391		Resistance{Ohm: self * rhs.Ohm.clone()}
13392	}
13393}
13394/// Multiplying a unit value by a scalar value returns a unit value
13395#[cfg(feature="num-complex")]
13396impl core::ops::Mul<&Resistance<num_complex::Complex64>> for &num_complex::Complex64 {
13397	type Output = Resistance<num_complex::Complex64>;
13398	fn mul(self, rhs: &Resistance<num_complex::Complex64>) -> Self::Output {
13399		Resistance{Ohm: self.clone() * rhs.Ohm.clone()}
13400	}
13401}
13402
13403
13404
13405/// Converts a Resistance into the equivalent [uom](https://crates.io/crates/uom) type [ElectricalResistance](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricalResistance.html)
13406#[cfg(feature = "uom")]
13407impl<T> Into<uom::si::f32::ElectricalResistance> for Resistance<T> where T: NumLike+Into<f32> {
13408	fn into(self) -> uom::si::f32::ElectricalResistance {
13409		uom::si::f32::ElectricalResistance::new::<uom::si::electrical_resistance::ohm>(self.Ohm.into())
13410	}
13411}
13412
13413/// Creates a Resistance from the equivalent [uom](https://crates.io/crates/uom) type [ElectricalResistance](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricalResistance.html)
13414#[cfg(feature = "uom")]
13415impl<T> From<uom::si::f32::ElectricalResistance> for Resistance<T> where T: NumLike+From<f32> {
13416	fn from(src: uom::si::f32::ElectricalResistance) -> Self {
13417		Resistance{Ohm: T::from(src.value)}
13418	}
13419}
13420
13421/// Converts a Resistance into the equivalent [uom](https://crates.io/crates/uom) type [ElectricalResistance](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricalResistance.html)
13422#[cfg(feature = "uom")]
13423impl<T> Into<uom::si::f64::ElectricalResistance> for Resistance<T> where T: NumLike+Into<f64> {
13424	fn into(self) -> uom::si::f64::ElectricalResistance {
13425		uom::si::f64::ElectricalResistance::new::<uom::si::electrical_resistance::ohm>(self.Ohm.into())
13426	}
13427}
13428
13429/// Creates a Resistance from the equivalent [uom](https://crates.io/crates/uom) type [ElectricalResistance](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricalResistance.html)
13430#[cfg(feature = "uom")]
13431impl<T> From<uom::si::f64::ElectricalResistance> for Resistance<T> where T: NumLike+From<f64> {
13432	fn from(src: uom::si::f64::ElectricalResistance) -> Self {
13433		Resistance{Ohm: T::from(src.value)}
13434	}
13435}
13436
13437
13438// Resistance * Current -> Voltage
13439/// Multiplying a Resistance by a Current returns a value of type Voltage
13440impl<T> core::ops::Mul<Current<T>> for Resistance<T> where T: NumLike {
13441	type Output = Voltage<T>;
13442	fn mul(self, rhs: Current<T>) -> Self::Output {
13443		Voltage{V: self.Ohm * rhs.A}
13444	}
13445}
13446/// Multiplying a Resistance by a Current returns a value of type Voltage
13447impl<T> core::ops::Mul<Current<T>> for &Resistance<T> where T: NumLike {
13448	type Output = Voltage<T>;
13449	fn mul(self, rhs: Current<T>) -> Self::Output {
13450		Voltage{V: self.Ohm.clone() * rhs.A}
13451	}
13452}
13453/// Multiplying a Resistance by a Current returns a value of type Voltage
13454impl<T> core::ops::Mul<&Current<T>> for Resistance<T> where T: NumLike {
13455	type Output = Voltage<T>;
13456	fn mul(self, rhs: &Current<T>) -> Self::Output {
13457		Voltage{V: self.Ohm * rhs.A.clone()}
13458	}
13459}
13460/// Multiplying a Resistance by a Current returns a value of type Voltage
13461impl<T> core::ops::Mul<&Current<T>> for &Resistance<T> where T: NumLike {
13462	type Output = Voltage<T>;
13463	fn mul(self, rhs: &Current<T>) -> Self::Output {
13464		Voltage{V: self.Ohm.clone() * rhs.A.clone()}
13465	}
13466}
13467
13468// Resistance / InverseCurrent -> Voltage
13469/// Dividing a Resistance by a InverseCurrent returns a value of type Voltage
13470impl<T> core::ops::Div<InverseCurrent<T>> for Resistance<T> where T: NumLike {
13471	type Output = Voltage<T>;
13472	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
13473		Voltage{V: self.Ohm / rhs.per_A}
13474	}
13475}
13476/// Dividing a Resistance by a InverseCurrent returns a value of type Voltage
13477impl<T> core::ops::Div<InverseCurrent<T>> for &Resistance<T> where T: NumLike {
13478	type Output = Voltage<T>;
13479	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
13480		Voltage{V: self.Ohm.clone() / rhs.per_A}
13481	}
13482}
13483/// Dividing a Resistance by a InverseCurrent returns a value of type Voltage
13484impl<T> core::ops::Div<&InverseCurrent<T>> for Resistance<T> where T: NumLike {
13485	type Output = Voltage<T>;
13486	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
13487		Voltage{V: self.Ohm / rhs.per_A.clone()}
13488	}
13489}
13490/// Dividing a Resistance by a InverseCurrent returns a value of type Voltage
13491impl<T> core::ops::Div<&InverseCurrent<T>> for &Resistance<T> where T: NumLike {
13492	type Output = Voltage<T>;
13493	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
13494		Voltage{V: self.Ohm.clone() / rhs.per_A.clone()}
13495	}
13496}
13497
13498// Resistance * Time -> Inductance
13499/// Multiplying a Resistance by a Time returns a value of type Inductance
13500impl<T> core::ops::Mul<Time<T>> for Resistance<T> where T: NumLike {
13501	type Output = Inductance<T>;
13502	fn mul(self, rhs: Time<T>) -> Self::Output {
13503		Inductance{H: self.Ohm * rhs.s}
13504	}
13505}
13506/// Multiplying a Resistance by a Time returns a value of type Inductance
13507impl<T> core::ops::Mul<Time<T>> for &Resistance<T> where T: NumLike {
13508	type Output = Inductance<T>;
13509	fn mul(self, rhs: Time<T>) -> Self::Output {
13510		Inductance{H: self.Ohm.clone() * rhs.s}
13511	}
13512}
13513/// Multiplying a Resistance by a Time returns a value of type Inductance
13514impl<T> core::ops::Mul<&Time<T>> for Resistance<T> where T: NumLike {
13515	type Output = Inductance<T>;
13516	fn mul(self, rhs: &Time<T>) -> Self::Output {
13517		Inductance{H: self.Ohm * rhs.s.clone()}
13518	}
13519}
13520/// Multiplying a Resistance by a Time returns a value of type Inductance
13521impl<T> core::ops::Mul<&Time<T>> for &Resistance<T> where T: NumLike {
13522	type Output = Inductance<T>;
13523	fn mul(self, rhs: &Time<T>) -> Self::Output {
13524		Inductance{H: self.Ohm.clone() * rhs.s.clone()}
13525	}
13526}
13527
13528// Resistance / Time -> Elastance
13529/// Dividing a Resistance by a Time returns a value of type Elastance
13530impl<T> core::ops::Div<Time<T>> for Resistance<T> where T: NumLike {
13531	type Output = Elastance<T>;
13532	fn div(self, rhs: Time<T>) -> Self::Output {
13533		Elastance{per_F: self.Ohm / rhs.s}
13534	}
13535}
13536/// Dividing a Resistance by a Time returns a value of type Elastance
13537impl<T> core::ops::Div<Time<T>> for &Resistance<T> where T: NumLike {
13538	type Output = Elastance<T>;
13539	fn div(self, rhs: Time<T>) -> Self::Output {
13540		Elastance{per_F: self.Ohm.clone() / rhs.s}
13541	}
13542}
13543/// Dividing a Resistance by a Time returns a value of type Elastance
13544impl<T> core::ops::Div<&Time<T>> for Resistance<T> where T: NumLike {
13545	type Output = Elastance<T>;
13546	fn div(self, rhs: &Time<T>) -> Self::Output {
13547		Elastance{per_F: self.Ohm / rhs.s.clone()}
13548	}
13549}
13550/// Dividing a Resistance by a Time returns a value of type Elastance
13551impl<T> core::ops::Div<&Time<T>> for &Resistance<T> where T: NumLike {
13552	type Output = Elastance<T>;
13553	fn div(self, rhs: &Time<T>) -> Self::Output {
13554		Elastance{per_F: self.Ohm.clone() / rhs.s.clone()}
13555	}
13556}
13557
13558// Resistance * Capacitance -> Time
13559/// Multiplying a Resistance by a Capacitance returns a value of type Time
13560impl<T> core::ops::Mul<Capacitance<T>> for Resistance<T> where T: NumLike {
13561	type Output = Time<T>;
13562	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
13563		Time{s: self.Ohm * rhs.F}
13564	}
13565}
13566/// Multiplying a Resistance by a Capacitance returns a value of type Time
13567impl<T> core::ops::Mul<Capacitance<T>> for &Resistance<T> where T: NumLike {
13568	type Output = Time<T>;
13569	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
13570		Time{s: self.Ohm.clone() * rhs.F}
13571	}
13572}
13573/// Multiplying a Resistance by a Capacitance returns a value of type Time
13574impl<T> core::ops::Mul<&Capacitance<T>> for Resistance<T> where T: NumLike {
13575	type Output = Time<T>;
13576	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
13577		Time{s: self.Ohm * rhs.F.clone()}
13578	}
13579}
13580/// Multiplying a Resistance by a Capacitance returns a value of type Time
13581impl<T> core::ops::Mul<&Capacitance<T>> for &Resistance<T> where T: NumLike {
13582	type Output = Time<T>;
13583	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
13584		Time{s: self.Ohm.clone() * rhs.F.clone()}
13585	}
13586}
13587
13588// Resistance * Charge -> MagneticFlux
13589/// Multiplying a Resistance by a Charge returns a value of type MagneticFlux
13590impl<T> core::ops::Mul<Charge<T>> for Resistance<T> where T: NumLike {
13591	type Output = MagneticFlux<T>;
13592	fn mul(self, rhs: Charge<T>) -> Self::Output {
13593		MagneticFlux{Wb: self.Ohm * rhs.C}
13594	}
13595}
13596/// Multiplying a Resistance by a Charge returns a value of type MagneticFlux
13597impl<T> core::ops::Mul<Charge<T>> for &Resistance<T> where T: NumLike {
13598	type Output = MagneticFlux<T>;
13599	fn mul(self, rhs: Charge<T>) -> Self::Output {
13600		MagneticFlux{Wb: self.Ohm.clone() * rhs.C}
13601	}
13602}
13603/// Multiplying a Resistance by a Charge returns a value of type MagneticFlux
13604impl<T> core::ops::Mul<&Charge<T>> for Resistance<T> where T: NumLike {
13605	type Output = MagneticFlux<T>;
13606	fn mul(self, rhs: &Charge<T>) -> Self::Output {
13607		MagneticFlux{Wb: self.Ohm * rhs.C.clone()}
13608	}
13609}
13610/// Multiplying a Resistance by a Charge returns a value of type MagneticFlux
13611impl<T> core::ops::Mul<&Charge<T>> for &Resistance<T> where T: NumLike {
13612	type Output = MagneticFlux<T>;
13613	fn mul(self, rhs: &Charge<T>) -> Self::Output {
13614		MagneticFlux{Wb: self.Ohm.clone() * rhs.C.clone()}
13615	}
13616}
13617
13618// Resistance / Elastance -> Time
13619/// Dividing a Resistance by a Elastance returns a value of type Time
13620impl<T> core::ops::Div<Elastance<T>> for Resistance<T> where T: NumLike {
13621	type Output = Time<T>;
13622	fn div(self, rhs: Elastance<T>) -> Self::Output {
13623		Time{s: self.Ohm / rhs.per_F}
13624	}
13625}
13626/// Dividing a Resistance by a Elastance returns a value of type Time
13627impl<T> core::ops::Div<Elastance<T>> for &Resistance<T> where T: NumLike {
13628	type Output = Time<T>;
13629	fn div(self, rhs: Elastance<T>) -> Self::Output {
13630		Time{s: self.Ohm.clone() / rhs.per_F}
13631	}
13632}
13633/// Dividing a Resistance by a Elastance returns a value of type Time
13634impl<T> core::ops::Div<&Elastance<T>> for Resistance<T> where T: NumLike {
13635	type Output = Time<T>;
13636	fn div(self, rhs: &Elastance<T>) -> Self::Output {
13637		Time{s: self.Ohm / rhs.per_F.clone()}
13638	}
13639}
13640/// Dividing a Resistance by a Elastance returns a value of type Time
13641impl<T> core::ops::Div<&Elastance<T>> for &Resistance<T> where T: NumLike {
13642	type Output = Time<T>;
13643	fn div(self, rhs: &Elastance<T>) -> Self::Output {
13644		Time{s: self.Ohm.clone() / rhs.per_F.clone()}
13645	}
13646}
13647
13648// Resistance / Inductance -> Frequency
13649/// Dividing a Resistance by a Inductance returns a value of type Frequency
13650impl<T> core::ops::Div<Inductance<T>> for Resistance<T> where T: NumLike {
13651	type Output = Frequency<T>;
13652	fn div(self, rhs: Inductance<T>) -> Self::Output {
13653		Frequency{Hz: self.Ohm / rhs.H}
13654	}
13655}
13656/// Dividing a Resistance by a Inductance returns a value of type Frequency
13657impl<T> core::ops::Div<Inductance<T>> for &Resistance<T> where T: NumLike {
13658	type Output = Frequency<T>;
13659	fn div(self, rhs: Inductance<T>) -> Self::Output {
13660		Frequency{Hz: self.Ohm.clone() / rhs.H}
13661	}
13662}
13663/// Dividing a Resistance by a Inductance returns a value of type Frequency
13664impl<T> core::ops::Div<&Inductance<T>> for Resistance<T> where T: NumLike {
13665	type Output = Frequency<T>;
13666	fn div(self, rhs: &Inductance<T>) -> Self::Output {
13667		Frequency{Hz: self.Ohm / rhs.H.clone()}
13668	}
13669}
13670/// Dividing a Resistance by a Inductance returns a value of type Frequency
13671impl<T> core::ops::Div<&Inductance<T>> for &Resistance<T> where T: NumLike {
13672	type Output = Frequency<T>;
13673	fn div(self, rhs: &Inductance<T>) -> Self::Output {
13674		Frequency{Hz: self.Ohm.clone() / rhs.H.clone()}
13675	}
13676}
13677
13678// Resistance / InverseCharge -> MagneticFlux
13679/// Dividing a Resistance by a InverseCharge returns a value of type MagneticFlux
13680impl<T> core::ops::Div<InverseCharge<T>> for Resistance<T> where T: NumLike {
13681	type Output = MagneticFlux<T>;
13682	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
13683		MagneticFlux{Wb: self.Ohm / rhs.per_C}
13684	}
13685}
13686/// Dividing a Resistance by a InverseCharge returns a value of type MagneticFlux
13687impl<T> core::ops::Div<InverseCharge<T>> for &Resistance<T> where T: NumLike {
13688	type Output = MagneticFlux<T>;
13689	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
13690		MagneticFlux{Wb: self.Ohm.clone() / rhs.per_C}
13691	}
13692}
13693/// Dividing a Resistance by a InverseCharge returns a value of type MagneticFlux
13694impl<T> core::ops::Div<&InverseCharge<T>> for Resistance<T> where T: NumLike {
13695	type Output = MagneticFlux<T>;
13696	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
13697		MagneticFlux{Wb: self.Ohm / rhs.per_C.clone()}
13698	}
13699}
13700/// Dividing a Resistance by a InverseCharge returns a value of type MagneticFlux
13701impl<T> core::ops::Div<&InverseCharge<T>> for &Resistance<T> where T: NumLike {
13702	type Output = MagneticFlux<T>;
13703	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
13704		MagneticFlux{Wb: self.Ohm.clone() / rhs.per_C.clone()}
13705	}
13706}
13707
13708// Resistance * InverseInductance -> Frequency
13709/// Multiplying a Resistance by a InverseInductance returns a value of type Frequency
13710impl<T> core::ops::Mul<InverseInductance<T>> for Resistance<T> where T: NumLike {
13711	type Output = Frequency<T>;
13712	fn mul(self, rhs: InverseInductance<T>) -> Self::Output {
13713		Frequency{Hz: self.Ohm * rhs.per_H}
13714	}
13715}
13716/// Multiplying a Resistance by a InverseInductance returns a value of type Frequency
13717impl<T> core::ops::Mul<InverseInductance<T>> for &Resistance<T> where T: NumLike {
13718	type Output = Frequency<T>;
13719	fn mul(self, rhs: InverseInductance<T>) -> Self::Output {
13720		Frequency{Hz: self.Ohm.clone() * rhs.per_H}
13721	}
13722}
13723/// Multiplying a Resistance by a InverseInductance returns a value of type Frequency
13724impl<T> core::ops::Mul<&InverseInductance<T>> for Resistance<T> where T: NumLike {
13725	type Output = Frequency<T>;
13726	fn mul(self, rhs: &InverseInductance<T>) -> Self::Output {
13727		Frequency{Hz: self.Ohm * rhs.per_H.clone()}
13728	}
13729}
13730/// Multiplying a Resistance by a InverseInductance returns a value of type Frequency
13731impl<T> core::ops::Mul<&InverseInductance<T>> for &Resistance<T> where T: NumLike {
13732	type Output = Frequency<T>;
13733	fn mul(self, rhs: &InverseInductance<T>) -> Self::Output {
13734		Frequency{Hz: self.Ohm.clone() * rhs.per_H.clone()}
13735	}
13736}
13737
13738// Resistance * InverseMagneticFlux -> InverseCharge
13739/// Multiplying a Resistance by a InverseMagneticFlux returns a value of type InverseCharge
13740impl<T> core::ops::Mul<InverseMagneticFlux<T>> for Resistance<T> where T: NumLike {
13741	type Output = InverseCharge<T>;
13742	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
13743		InverseCharge{per_C: self.Ohm * rhs.per_Wb}
13744	}
13745}
13746/// Multiplying a Resistance by a InverseMagneticFlux returns a value of type InverseCharge
13747impl<T> core::ops::Mul<InverseMagneticFlux<T>> for &Resistance<T> where T: NumLike {
13748	type Output = InverseCharge<T>;
13749	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
13750		InverseCharge{per_C: self.Ohm.clone() * rhs.per_Wb}
13751	}
13752}
13753/// Multiplying a Resistance by a InverseMagneticFlux returns a value of type InverseCharge
13754impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for Resistance<T> where T: NumLike {
13755	type Output = InverseCharge<T>;
13756	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
13757		InverseCharge{per_C: self.Ohm * rhs.per_Wb.clone()}
13758	}
13759}
13760/// Multiplying a Resistance by a InverseMagneticFlux returns a value of type InverseCharge
13761impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for &Resistance<T> where T: NumLike {
13762	type Output = InverseCharge<T>;
13763	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
13764		InverseCharge{per_C: self.Ohm.clone() * rhs.per_Wb.clone()}
13765	}
13766}
13767
13768// Resistance * InverseVoltage -> InverseCurrent
13769/// Multiplying a Resistance by a InverseVoltage returns a value of type InverseCurrent
13770impl<T> core::ops::Mul<InverseVoltage<T>> for Resistance<T> where T: NumLike {
13771	type Output = InverseCurrent<T>;
13772	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
13773		InverseCurrent{per_A: self.Ohm * rhs.per_V}
13774	}
13775}
13776/// Multiplying a Resistance by a InverseVoltage returns a value of type InverseCurrent
13777impl<T> core::ops::Mul<InverseVoltage<T>> for &Resistance<T> where T: NumLike {
13778	type Output = InverseCurrent<T>;
13779	fn mul(self, rhs: InverseVoltage<T>) -> Self::Output {
13780		InverseCurrent{per_A: self.Ohm.clone() * rhs.per_V}
13781	}
13782}
13783/// Multiplying a Resistance by a InverseVoltage returns a value of type InverseCurrent
13784impl<T> core::ops::Mul<&InverseVoltage<T>> for Resistance<T> where T: NumLike {
13785	type Output = InverseCurrent<T>;
13786	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
13787		InverseCurrent{per_A: self.Ohm * rhs.per_V.clone()}
13788	}
13789}
13790/// Multiplying a Resistance by a InverseVoltage returns a value of type InverseCurrent
13791impl<T> core::ops::Mul<&InverseVoltage<T>> for &Resistance<T> where T: NumLike {
13792	type Output = InverseCurrent<T>;
13793	fn mul(self, rhs: &InverseVoltage<T>) -> Self::Output {
13794		InverseCurrent{per_A: self.Ohm.clone() * rhs.per_V.clone()}
13795	}
13796}
13797
13798// Resistance / MagneticFlux -> InverseCharge
13799/// Dividing a Resistance by a MagneticFlux returns a value of type InverseCharge
13800impl<T> core::ops::Div<MagneticFlux<T>> for Resistance<T> where T: NumLike {
13801	type Output = InverseCharge<T>;
13802	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
13803		InverseCharge{per_C: self.Ohm / rhs.Wb}
13804	}
13805}
13806/// Dividing a Resistance by a MagneticFlux returns a value of type InverseCharge
13807impl<T> core::ops::Div<MagneticFlux<T>> for &Resistance<T> where T: NumLike {
13808	type Output = InverseCharge<T>;
13809	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
13810		InverseCharge{per_C: self.Ohm.clone() / rhs.Wb}
13811	}
13812}
13813/// Dividing a Resistance by a MagneticFlux returns a value of type InverseCharge
13814impl<T> core::ops::Div<&MagneticFlux<T>> for Resistance<T> where T: NumLike {
13815	type Output = InverseCharge<T>;
13816	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
13817		InverseCharge{per_C: self.Ohm / rhs.Wb.clone()}
13818	}
13819}
13820/// Dividing a Resistance by a MagneticFlux returns a value of type InverseCharge
13821impl<T> core::ops::Div<&MagneticFlux<T>> for &Resistance<T> where T: NumLike {
13822	type Output = InverseCharge<T>;
13823	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
13824		InverseCharge{per_C: self.Ohm.clone() / rhs.Wb.clone()}
13825	}
13826}
13827
13828// Resistance / Voltage -> InverseCurrent
13829/// Dividing a Resistance by a Voltage returns a value of type InverseCurrent
13830impl<T> core::ops::Div<Voltage<T>> for Resistance<T> where T: NumLike {
13831	type Output = InverseCurrent<T>;
13832	fn div(self, rhs: Voltage<T>) -> Self::Output {
13833		InverseCurrent{per_A: self.Ohm / rhs.V}
13834	}
13835}
13836/// Dividing a Resistance by a Voltage returns a value of type InverseCurrent
13837impl<T> core::ops::Div<Voltage<T>> for &Resistance<T> where T: NumLike {
13838	type Output = InverseCurrent<T>;
13839	fn div(self, rhs: Voltage<T>) -> Self::Output {
13840		InverseCurrent{per_A: self.Ohm.clone() / rhs.V}
13841	}
13842}
13843/// Dividing a Resistance by a Voltage returns a value of type InverseCurrent
13844impl<T> core::ops::Div<&Voltage<T>> for Resistance<T> where T: NumLike {
13845	type Output = InverseCurrent<T>;
13846	fn div(self, rhs: &Voltage<T>) -> Self::Output {
13847		InverseCurrent{per_A: self.Ohm / rhs.V.clone()}
13848	}
13849}
13850/// Dividing a Resistance by a Voltage returns a value of type InverseCurrent
13851impl<T> core::ops::Div<&Voltage<T>> for &Resistance<T> where T: NumLike {
13852	type Output = InverseCurrent<T>;
13853	fn div(self, rhs: &Voltage<T>) -> Self::Output {
13854		InverseCurrent{per_A: self.Ohm.clone() / rhs.V.clone()}
13855	}
13856}
13857
13858// Resistance * Frequency -> Elastance
13859/// Multiplying a Resistance by a Frequency returns a value of type Elastance
13860impl<T> core::ops::Mul<Frequency<T>> for Resistance<T> where T: NumLike {
13861	type Output = Elastance<T>;
13862	fn mul(self, rhs: Frequency<T>) -> Self::Output {
13863		Elastance{per_F: self.Ohm * rhs.Hz}
13864	}
13865}
13866/// Multiplying a Resistance by a Frequency returns a value of type Elastance
13867impl<T> core::ops::Mul<Frequency<T>> for &Resistance<T> where T: NumLike {
13868	type Output = Elastance<T>;
13869	fn mul(self, rhs: Frequency<T>) -> Self::Output {
13870		Elastance{per_F: self.Ohm.clone() * rhs.Hz}
13871	}
13872}
13873/// Multiplying a Resistance by a Frequency returns a value of type Elastance
13874impl<T> core::ops::Mul<&Frequency<T>> for Resistance<T> where T: NumLike {
13875	type Output = Elastance<T>;
13876	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
13877		Elastance{per_F: self.Ohm * rhs.Hz.clone()}
13878	}
13879}
13880/// Multiplying a Resistance by a Frequency returns a value of type Elastance
13881impl<T> core::ops::Mul<&Frequency<T>> for &Resistance<T> where T: NumLike {
13882	type Output = Elastance<T>;
13883	fn mul(self, rhs: &Frequency<T>) -> Self::Output {
13884		Elastance{per_F: self.Ohm.clone() * rhs.Hz.clone()}
13885	}
13886}
13887
13888// Resistance / Frequency -> Inductance
13889/// Dividing a Resistance by a Frequency returns a value of type Inductance
13890impl<T> core::ops::Div<Frequency<T>> for Resistance<T> where T: NumLike {
13891	type Output = Inductance<T>;
13892	fn div(self, rhs: Frequency<T>) -> Self::Output {
13893		Inductance{H: self.Ohm / rhs.Hz}
13894	}
13895}
13896/// Dividing a Resistance by a Frequency returns a value of type Inductance
13897impl<T> core::ops::Div<Frequency<T>> for &Resistance<T> where T: NumLike {
13898	type Output = Inductance<T>;
13899	fn div(self, rhs: Frequency<T>) -> Self::Output {
13900		Inductance{H: self.Ohm.clone() / rhs.Hz}
13901	}
13902}
13903/// Dividing a Resistance by a Frequency returns a value of type Inductance
13904impl<T> core::ops::Div<&Frequency<T>> for Resistance<T> where T: NumLike {
13905	type Output = Inductance<T>;
13906	fn div(self, rhs: &Frequency<T>) -> Self::Output {
13907		Inductance{H: self.Ohm / rhs.Hz.clone()}
13908	}
13909}
13910/// Dividing a Resistance by a Frequency returns a value of type Inductance
13911impl<T> core::ops::Div<&Frequency<T>> for &Resistance<T> where T: NumLike {
13912	type Output = Inductance<T>;
13913	fn div(self, rhs: &Frequency<T>) -> Self::Output {
13914		Inductance{H: self.Ohm.clone() / rhs.Hz.clone()}
13915	}
13916}
13917
13918// 1/Resistance -> Conductance
13919/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13920impl<T> core::ops::Div<Resistance<T>> for f64 where T: NumLike+From<f64> {
13921	type Output = Conductance<T>;
13922	fn div(self, rhs: Resistance<T>) -> Self::Output {
13923		Conductance{S: T::from(self) / rhs.Ohm}
13924	}
13925}
13926/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13927impl<T> core::ops::Div<Resistance<T>> for &f64 where T: NumLike+From<f64> {
13928	type Output = Conductance<T>;
13929	fn div(self, rhs: Resistance<T>) -> Self::Output {
13930		Conductance{S: T::from(self.clone()) / rhs.Ohm}
13931	}
13932}
13933/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13934impl<T> core::ops::Div<&Resistance<T>> for f64 where T: NumLike+From<f64> {
13935	type Output = Conductance<T>;
13936	fn div(self, rhs: &Resistance<T>) -> Self::Output {
13937		Conductance{S: T::from(self) / rhs.Ohm.clone()}
13938	}
13939}
13940/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13941impl<T> core::ops::Div<&Resistance<T>> for &f64 where T: NumLike+From<f64> {
13942	type Output = Conductance<T>;
13943	fn div(self, rhs: &Resistance<T>) -> Self::Output {
13944		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
13945	}
13946}
13947
13948// 1/Resistance -> Conductance
13949/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13950impl<T> core::ops::Div<Resistance<T>> for f32 where T: NumLike+From<f32> {
13951	type Output = Conductance<T>;
13952	fn div(self, rhs: Resistance<T>) -> Self::Output {
13953		Conductance{S: T::from(self) / rhs.Ohm}
13954	}
13955}
13956/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13957impl<T> core::ops::Div<Resistance<T>> for &f32 where T: NumLike+From<f32> {
13958	type Output = Conductance<T>;
13959	fn div(self, rhs: Resistance<T>) -> Self::Output {
13960		Conductance{S: T::from(self.clone()) / rhs.Ohm}
13961	}
13962}
13963/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13964impl<T> core::ops::Div<&Resistance<T>> for f32 where T: NumLike+From<f32> {
13965	type Output = Conductance<T>;
13966	fn div(self, rhs: &Resistance<T>) -> Self::Output {
13967		Conductance{S: T::from(self) / rhs.Ohm.clone()}
13968	}
13969}
13970/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13971impl<T> core::ops::Div<&Resistance<T>> for &f32 where T: NumLike+From<f32> {
13972	type Output = Conductance<T>;
13973	fn div(self, rhs: &Resistance<T>) -> Self::Output {
13974		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
13975	}
13976}
13977
13978// 1/Resistance -> Conductance
13979/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13980impl<T> core::ops::Div<Resistance<T>> for i64 where T: NumLike+From<i64> {
13981	type Output = Conductance<T>;
13982	fn div(self, rhs: Resistance<T>) -> Self::Output {
13983		Conductance{S: T::from(self) / rhs.Ohm}
13984	}
13985}
13986/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13987impl<T> core::ops::Div<Resistance<T>> for &i64 where T: NumLike+From<i64> {
13988	type Output = Conductance<T>;
13989	fn div(self, rhs: Resistance<T>) -> Self::Output {
13990		Conductance{S: T::from(self.clone()) / rhs.Ohm}
13991	}
13992}
13993/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
13994impl<T> core::ops::Div<&Resistance<T>> for i64 where T: NumLike+From<i64> {
13995	type Output = Conductance<T>;
13996	fn div(self, rhs: &Resistance<T>) -> Self::Output {
13997		Conductance{S: T::from(self) / rhs.Ohm.clone()}
13998	}
13999}
14000/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14001impl<T> core::ops::Div<&Resistance<T>> for &i64 where T: NumLike+From<i64> {
14002	type Output = Conductance<T>;
14003	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14004		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
14005	}
14006}
14007
14008// 1/Resistance -> Conductance
14009/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14010impl<T> core::ops::Div<Resistance<T>> for i32 where T: NumLike+From<i32> {
14011	type Output = Conductance<T>;
14012	fn div(self, rhs: Resistance<T>) -> Self::Output {
14013		Conductance{S: T::from(self) / rhs.Ohm}
14014	}
14015}
14016/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14017impl<T> core::ops::Div<Resistance<T>> for &i32 where T: NumLike+From<i32> {
14018	type Output = Conductance<T>;
14019	fn div(self, rhs: Resistance<T>) -> Self::Output {
14020		Conductance{S: T::from(self.clone()) / rhs.Ohm}
14021	}
14022}
14023/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14024impl<T> core::ops::Div<&Resistance<T>> for i32 where T: NumLike+From<i32> {
14025	type Output = Conductance<T>;
14026	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14027		Conductance{S: T::from(self) / rhs.Ohm.clone()}
14028	}
14029}
14030/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14031impl<T> core::ops::Div<&Resistance<T>> for &i32 where T: NumLike+From<i32> {
14032	type Output = Conductance<T>;
14033	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14034		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
14035	}
14036}
14037
14038// 1/Resistance -> Conductance
14039/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14040#[cfg(feature="num-bigfloat")]
14041impl<T> core::ops::Div<Resistance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
14042	type Output = Conductance<T>;
14043	fn div(self, rhs: Resistance<T>) -> Self::Output {
14044		Conductance{S: T::from(self) / rhs.Ohm}
14045	}
14046}
14047/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14048#[cfg(feature="num-bigfloat")]
14049impl<T> core::ops::Div<Resistance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
14050	type Output = Conductance<T>;
14051	fn div(self, rhs: Resistance<T>) -> Self::Output {
14052		Conductance{S: T::from(self.clone()) / rhs.Ohm}
14053	}
14054}
14055/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14056#[cfg(feature="num-bigfloat")]
14057impl<T> core::ops::Div<&Resistance<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
14058	type Output = Conductance<T>;
14059	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14060		Conductance{S: T::from(self) / rhs.Ohm.clone()}
14061	}
14062}
14063/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14064#[cfg(feature="num-bigfloat")]
14065impl<T> core::ops::Div<&Resistance<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
14066	type Output = Conductance<T>;
14067	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14068		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
14069	}
14070}
14071
14072// 1/Resistance -> Conductance
14073/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14074#[cfg(feature="num-complex")]
14075impl<T> core::ops::Div<Resistance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
14076	type Output = Conductance<T>;
14077	fn div(self, rhs: Resistance<T>) -> Self::Output {
14078		Conductance{S: T::from(self) / rhs.Ohm}
14079	}
14080}
14081/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14082#[cfg(feature="num-complex")]
14083impl<T> core::ops::Div<Resistance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
14084	type Output = Conductance<T>;
14085	fn div(self, rhs: Resistance<T>) -> Self::Output {
14086		Conductance{S: T::from(self.clone()) / rhs.Ohm}
14087	}
14088}
14089/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14090#[cfg(feature="num-complex")]
14091impl<T> core::ops::Div<&Resistance<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
14092	type Output = Conductance<T>;
14093	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14094		Conductance{S: T::from(self) / rhs.Ohm.clone()}
14095	}
14096}
14097/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14098#[cfg(feature="num-complex")]
14099impl<T> core::ops::Div<&Resistance<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
14100	type Output = Conductance<T>;
14101	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14102		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
14103	}
14104}
14105
14106// 1/Resistance -> Conductance
14107/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14108#[cfg(feature="num-complex")]
14109impl<T> core::ops::Div<Resistance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
14110	type Output = Conductance<T>;
14111	fn div(self, rhs: Resistance<T>) -> Self::Output {
14112		Conductance{S: T::from(self) / rhs.Ohm}
14113	}
14114}
14115/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14116#[cfg(feature="num-complex")]
14117impl<T> core::ops::Div<Resistance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
14118	type Output = Conductance<T>;
14119	fn div(self, rhs: Resistance<T>) -> Self::Output {
14120		Conductance{S: T::from(self.clone()) / rhs.Ohm}
14121	}
14122}
14123/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14124#[cfg(feature="num-complex")]
14125impl<T> core::ops::Div<&Resistance<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
14126	type Output = Conductance<T>;
14127	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14128		Conductance{S: T::from(self) / rhs.Ohm.clone()}
14129	}
14130}
14131/// Dividing a scalar value by a Resistance unit value returns a value of type Conductance
14132#[cfg(feature="num-complex")]
14133impl<T> core::ops::Div<&Resistance<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
14134	type Output = Conductance<T>;
14135	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14136		Conductance{S: T::from(self.clone()) / rhs.Ohm.clone()}
14137	}
14138}
14139
14140/// The voltage unit type, defined as volts in SI units
14141#[derive(UnitStruct, Debug, Clone)]
14142#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
14143pub struct Voltage<T: NumLike>{
14144	/// The value of this Voltage in volts
14145	pub V: T
14146}
14147
14148impl<T> Voltage<T> where T: NumLike {
14149
14150	/// Returns the standard unit name of voltage: "volts"
14151	pub fn unit_name() -> &'static str { "volts" }
14152	
14153	/// Returns the abbreviated name or symbol of voltage: "V" for volts
14154	pub fn unit_symbol() -> &'static str { "V" }
14155	
14156	/// Returns a new voltage value from the given number of volts
14157	///
14158	/// # Arguments
14159	/// * `V` - Any number-like type, representing a quantity of volts
14160	pub fn from_V(V: T) -> Self { Voltage{V: V} }
14161	
14162	/// Returns a copy of this voltage value in volts
14163	pub fn to_V(&self) -> T { self.V.clone() }
14164
14165	/// Returns a new voltage value from the given number of volts
14166	///
14167	/// # Arguments
14168	/// * `volts` - Any number-like type, representing a quantity of volts
14169	pub fn from_volts(volts: T) -> Self { Voltage{V: volts} }
14170	
14171	/// Returns a copy of this voltage value in volts
14172	pub fn to_volts(&self) -> T { self.V.clone() }
14173
14174}
14175
14176impl<T> fmt::Display for Voltage<T> where T: NumLike {
14177	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14178		write!(f, "{} {}", &self.V, Self::unit_symbol())
14179	}
14180}
14181
14182impl<T> Voltage<T> where T: NumLike+From<f64> {
14183	
14184	/// Returns a copy of this voltage value in millivolts
14185	/// 
14186	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14187	pub fn to_mV(&self) -> T {
14188		return self.V.clone() * T::from(1000.0_f64);
14189	}
14190
14191	/// Returns a new voltage value from the given number of millivolts
14192	/// 
14193	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14194	///
14195	/// # Arguments
14196	/// * `mV` - Any number-like type, representing a quantity of millivolts
14197	pub fn from_mV(mV: T) -> Self {
14198		Voltage{V: mV * T::from(0.001_f64)}
14199	}
14200
14201	/// Returns a copy of this voltage value in microvolts
14202	/// 
14203	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14204	pub fn to_uV(&self) -> T {
14205		return self.V.clone() * T::from(1000000.0_f64);
14206	}
14207
14208	/// Returns a new voltage value from the given number of microvolts
14209	/// 
14210	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14211	///
14212	/// # Arguments
14213	/// * `uV` - Any number-like type, representing a quantity of microvolts
14214	pub fn from_uV(uV: T) -> Self {
14215		Voltage{V: uV * T::from(1e-06_f64)}
14216	}
14217
14218	/// Returns a copy of this voltage value in nanovolts
14219	/// 
14220	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14221	pub fn to_nV(&self) -> T {
14222		return self.V.clone() * T::from(1000000000.0_f64);
14223	}
14224
14225	/// Returns a new voltage value from the given number of nanovolts
14226	/// 
14227	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14228	///
14229	/// # Arguments
14230	/// * `nV` - Any number-like type, representing a quantity of nanovolts
14231	pub fn from_nV(nV: T) -> Self {
14232		Voltage{V: nV * T::from(1e-09_f64)}
14233	}
14234
14235	/// Returns a copy of this voltage value in kilovolts
14236	/// 
14237	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14238	pub fn to_kV(&self) -> T {
14239		return self.V.clone() * T::from(0.001_f64);
14240	}
14241
14242	/// Returns a new voltage value from the given number of kilovolts
14243	/// 
14244	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14245	///
14246	/// # Arguments
14247	/// * `kV` - Any number-like type, representing a quantity of kilovolts
14248	pub fn from_kV(kV: T) -> Self {
14249		Voltage{V: kV * T::from(1000.0_f64)}
14250	}
14251
14252	/// Returns a copy of this voltage value in megavolts
14253	/// 
14254	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14255	pub fn to_MV(&self) -> T {
14256		return self.V.clone() * T::from(1e-06_f64);
14257	}
14258
14259	/// Returns a new voltage value from the given number of megavolts
14260	/// 
14261	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14262	///
14263	/// # Arguments
14264	/// * `MV` - Any number-like type, representing a quantity of megavolts
14265	pub fn from_MV(MV: T) -> Self {
14266		Voltage{V: MV * T::from(1000000.0_f64)}
14267	}
14268
14269	/// Returns a copy of this voltage value in gigavolts
14270	/// 
14271	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14272	pub fn to_GV(&self) -> T {
14273		return self.V.clone() * T::from(1e-09_f64);
14274	}
14275
14276	/// Returns a new voltage value from the given number of gigavolts
14277	/// 
14278	/// *Note: This method is not available for `f32` and other number types lacking the `From<f64>` trait*
14279	///
14280	/// # Arguments
14281	/// * `GV` - Any number-like type, representing a quantity of gigavolts
14282	pub fn from_GV(GV: T) -> Self {
14283		Voltage{V: GV * T::from(1000000000.0_f64)}
14284	}
14285
14286}
14287
14288
14289/// Multiplying a unit value by a scalar value returns a unit value
14290#[cfg(feature="num-bigfloat")]
14291impl core::ops::Mul<Voltage<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
14292	type Output = Voltage<num_bigfloat::BigFloat>;
14293	fn mul(self, rhs: Voltage<num_bigfloat::BigFloat>) -> Self::Output {
14294		Voltage{V: self * rhs.V}
14295	}
14296}
14297/// Multiplying a unit value by a scalar value returns a unit value
14298#[cfg(feature="num-bigfloat")]
14299impl core::ops::Mul<Voltage<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
14300	type Output = Voltage<num_bigfloat::BigFloat>;
14301	fn mul(self, rhs: Voltage<num_bigfloat::BigFloat>) -> Self::Output {
14302		Voltage{V: self.clone() * rhs.V}
14303	}
14304}
14305/// Multiplying a unit value by a scalar value returns a unit value
14306#[cfg(feature="num-bigfloat")]
14307impl core::ops::Mul<&Voltage<num_bigfloat::BigFloat>> for num_bigfloat::BigFloat {
14308	type Output = Voltage<num_bigfloat::BigFloat>;
14309	fn mul(self, rhs: &Voltage<num_bigfloat::BigFloat>) -> Self::Output {
14310		Voltage{V: self * rhs.V.clone()}
14311	}
14312}
14313/// Multiplying a unit value by a scalar value returns a unit value
14314#[cfg(feature="num-bigfloat")]
14315impl core::ops::Mul<&Voltage<num_bigfloat::BigFloat>> for &num_bigfloat::BigFloat {
14316	type Output = Voltage<num_bigfloat::BigFloat>;
14317	fn mul(self, rhs: &Voltage<num_bigfloat::BigFloat>) -> Self::Output {
14318		Voltage{V: self.clone() * rhs.V.clone()}
14319	}
14320}
14321
14322/// Multiplying a unit value by a scalar value returns a unit value
14323#[cfg(feature="num-complex")]
14324impl core::ops::Mul<Voltage<num_complex::Complex32>> for num_complex::Complex32 {
14325	type Output = Voltage<num_complex::Complex32>;
14326	fn mul(self, rhs: Voltage<num_complex::Complex32>) -> Self::Output {
14327		Voltage{V: self * rhs.V}
14328	}
14329}
14330/// Multiplying a unit value by a scalar value returns a unit value
14331#[cfg(feature="num-complex")]
14332impl core::ops::Mul<Voltage<num_complex::Complex32>> for &num_complex::Complex32 {
14333	type Output = Voltage<num_complex::Complex32>;
14334	fn mul(self, rhs: Voltage<num_complex::Complex32>) -> Self::Output {
14335		Voltage{V: self.clone() * rhs.V}
14336	}
14337}
14338/// Multiplying a unit value by a scalar value returns a unit value
14339#[cfg(feature="num-complex")]
14340impl core::ops::Mul<&Voltage<num_complex::Complex32>> for num_complex::Complex32 {
14341	type Output = Voltage<num_complex::Complex32>;
14342	fn mul(self, rhs: &Voltage<num_complex::Complex32>) -> Self::Output {
14343		Voltage{V: self * rhs.V.clone()}
14344	}
14345}
14346/// Multiplying a unit value by a scalar value returns a unit value
14347#[cfg(feature="num-complex")]
14348impl core::ops::Mul<&Voltage<num_complex::Complex32>> for &num_complex::Complex32 {
14349	type Output = Voltage<num_complex::Complex32>;
14350	fn mul(self, rhs: &Voltage<num_complex::Complex32>) -> Self::Output {
14351		Voltage{V: self.clone() * rhs.V.clone()}
14352	}
14353}
14354
14355/// Multiplying a unit value by a scalar value returns a unit value
14356#[cfg(feature="num-complex")]
14357impl core::ops::Mul<Voltage<num_complex::Complex64>> for num_complex::Complex64 {
14358	type Output = Voltage<num_complex::Complex64>;
14359	fn mul(self, rhs: Voltage<num_complex::Complex64>) -> Self::Output {
14360		Voltage{V: self * rhs.V}
14361	}
14362}
14363/// Multiplying a unit value by a scalar value returns a unit value
14364#[cfg(feature="num-complex")]
14365impl core::ops::Mul<Voltage<num_complex::Complex64>> for &num_complex::Complex64 {
14366	type Output = Voltage<num_complex::Complex64>;
14367	fn mul(self, rhs: Voltage<num_complex::Complex64>) -> Self::Output {
14368		Voltage{V: self.clone() * rhs.V}
14369	}
14370}
14371/// Multiplying a unit value by a scalar value returns a unit value
14372#[cfg(feature="num-complex")]
14373impl core::ops::Mul<&Voltage<num_complex::Complex64>> for num_complex::Complex64 {
14374	type Output = Voltage<num_complex::Complex64>;
14375	fn mul(self, rhs: &Voltage<num_complex::Complex64>) -> Self::Output {
14376		Voltage{V: self * rhs.V.clone()}
14377	}
14378}
14379/// Multiplying a unit value by a scalar value returns a unit value
14380#[cfg(feature="num-complex")]
14381impl core::ops::Mul<&Voltage<num_complex::Complex64>> for &num_complex::Complex64 {
14382	type Output = Voltage<num_complex::Complex64>;
14383	fn mul(self, rhs: &Voltage<num_complex::Complex64>) -> Self::Output {
14384		Voltage{V: self.clone() * rhs.V.clone()}
14385	}
14386}
14387
14388
14389
14390/// Converts a Voltage into the equivalent [uom](https://crates.io/crates/uom) type [ElectricPotential](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricPotential.html)
14391#[cfg(feature = "uom")]
14392impl<T> Into<uom::si::f32::ElectricPotential> for Voltage<T> where T: NumLike+Into<f32> {
14393	fn into(self) -> uom::si::f32::ElectricPotential {
14394		uom::si::f32::ElectricPotential::new::<uom::si::electric_potential::volt>(self.V.into())
14395	}
14396}
14397
14398/// Creates a Voltage from the equivalent [uom](https://crates.io/crates/uom) type [ElectricPotential](https://docs.rs/uom/0.34.0/uom/si/f32/type.ElectricPotential.html)
14399#[cfg(feature = "uom")]
14400impl<T> From<uom::si::f32::ElectricPotential> for Voltage<T> where T: NumLike+From<f32> {
14401	fn from(src: uom::si::f32::ElectricPotential) -> Self {
14402		Voltage{V: T::from(src.value)}
14403	}
14404}
14405
14406/// Converts a Voltage into the equivalent [uom](https://crates.io/crates/uom) type [ElectricPotential](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricPotential.html)
14407#[cfg(feature = "uom")]
14408impl<T> Into<uom::si::f64::ElectricPotential> for Voltage<T> where T: NumLike+Into<f64> {
14409	fn into(self) -> uom::si::f64::ElectricPotential {
14410		uom::si::f64::ElectricPotential::new::<uom::si::electric_potential::volt>(self.V.into())
14411	}
14412}
14413
14414/// Creates a Voltage from the equivalent [uom](https://crates.io/crates/uom) type [ElectricPotential](https://docs.rs/uom/0.34.0/uom/si/f64/type.ElectricPotential.html)
14415#[cfg(feature = "uom")]
14416impl<T> From<uom::si::f64::ElectricPotential> for Voltage<T> where T: NumLike+From<f64> {
14417	fn from(src: uom::si::f64::ElectricPotential) -> Self {
14418		Voltage{V: T::from(src.value)}
14419	}
14420}
14421
14422
14423// Voltage * Current -> Power
14424/// Multiplying a Voltage by a Current returns a value of type Power
14425impl<T> core::ops::Mul<Current<T>> for Voltage<T> where T: NumLike {
14426	type Output = Power<T>;
14427	fn mul(self, rhs: Current<T>) -> Self::Output {
14428		Power{W: self.V * rhs.A}
14429	}
14430}
14431/// Multiplying a Voltage by a Current returns a value of type Power
14432impl<T> core::ops::Mul<Current<T>> for &Voltage<T> where T: NumLike {
14433	type Output = Power<T>;
14434	fn mul(self, rhs: Current<T>) -> Self::Output {
14435		Power{W: self.V.clone() * rhs.A}
14436	}
14437}
14438/// Multiplying a Voltage by a Current returns a value of type Power
14439impl<T> core::ops::Mul<&Current<T>> for Voltage<T> where T: NumLike {
14440	type Output = Power<T>;
14441	fn mul(self, rhs: &Current<T>) -> Self::Output {
14442		Power{W: self.V * rhs.A.clone()}
14443	}
14444}
14445/// Multiplying a Voltage by a Current returns a value of type Power
14446impl<T> core::ops::Mul<&Current<T>> for &Voltage<T> where T: NumLike {
14447	type Output = Power<T>;
14448	fn mul(self, rhs: &Current<T>) -> Self::Output {
14449		Power{W: self.V.clone() * rhs.A.clone()}
14450	}
14451}
14452
14453// Voltage / Current -> Resistance
14454/// Dividing a Voltage by a Current returns a value of type Resistance
14455impl<T> core::ops::Div<Current<T>> for Voltage<T> where T: NumLike {
14456	type Output = Resistance<T>;
14457	fn div(self, rhs: Current<T>) -> Self::Output {
14458		Resistance{Ohm: self.V / rhs.A}
14459	}
14460}
14461/// Dividing a Voltage by a Current returns a value of type Resistance
14462impl<T> core::ops::Div<Current<T>> for &Voltage<T> where T: NumLike {
14463	type Output = Resistance<T>;
14464	fn div(self, rhs: Current<T>) -> Self::Output {
14465		Resistance{Ohm: self.V.clone() / rhs.A}
14466	}
14467}
14468/// Dividing a Voltage by a Current returns a value of type Resistance
14469impl<T> core::ops::Div<&Current<T>> for Voltage<T> where T: NumLike {
14470	type Output = Resistance<T>;
14471	fn div(self, rhs: &Current<T>) -> Self::Output {
14472		Resistance{Ohm: self.V / rhs.A.clone()}
14473	}
14474}
14475/// Dividing a Voltage by a Current returns a value of type Resistance
14476impl<T> core::ops::Div<&Current<T>> for &Voltage<T> where T: NumLike {
14477	type Output = Resistance<T>;
14478	fn div(self, rhs: &Current<T>) -> Self::Output {
14479		Resistance{Ohm: self.V.clone() / rhs.A.clone()}
14480	}
14481}
14482
14483// Voltage * InverseCurrent -> Resistance
14484/// Multiplying a Voltage by a InverseCurrent returns a value of type Resistance
14485impl<T> core::ops::Mul<InverseCurrent<T>> for Voltage<T> where T: NumLike {
14486	type Output = Resistance<T>;
14487	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
14488		Resistance{Ohm: self.V * rhs.per_A}
14489	}
14490}
14491/// Multiplying a Voltage by a InverseCurrent returns a value of type Resistance
14492impl<T> core::ops::Mul<InverseCurrent<T>> for &Voltage<T> where T: NumLike {
14493	type Output = Resistance<T>;
14494	fn mul(self, rhs: InverseCurrent<T>) -> Self::Output {
14495		Resistance{Ohm: self.V.clone() * rhs.per_A}
14496	}
14497}
14498/// Multiplying a Voltage by a InverseCurrent returns a value of type Resistance
14499impl<T> core::ops::Mul<&InverseCurrent<T>> for Voltage<T> where T: NumLike {
14500	type Output = Resistance<T>;
14501	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
14502		Resistance{Ohm: self.V * rhs.per_A.clone()}
14503	}
14504}
14505/// Multiplying a Voltage by a InverseCurrent returns a value of type Resistance
14506impl<T> core::ops::Mul<&InverseCurrent<T>> for &Voltage<T> where T: NumLike {
14507	type Output = Resistance<T>;
14508	fn mul(self, rhs: &InverseCurrent<T>) -> Self::Output {
14509		Resistance{Ohm: self.V.clone() * rhs.per_A.clone()}
14510	}
14511}
14512
14513// Voltage / InverseCurrent -> Power
14514/// Dividing a Voltage by a InverseCurrent returns a value of type Power
14515impl<T> core::ops::Div<InverseCurrent<T>> for Voltage<T> where T: NumLike {
14516	type Output = Power<T>;
14517	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
14518		Power{W: self.V / rhs.per_A}
14519	}
14520}
14521/// Dividing a Voltage by a InverseCurrent returns a value of type Power
14522impl<T> core::ops::Div<InverseCurrent<T>> for &Voltage<T> where T: NumLike {
14523	type Output = Power<T>;
14524	fn div(self, rhs: InverseCurrent<T>) -> Self::Output {
14525		Power{W: self.V.clone() / rhs.per_A}
14526	}
14527}
14528/// Dividing a Voltage by a InverseCurrent returns a value of type Power
14529impl<T> core::ops::Div<&InverseCurrent<T>> for Voltage<T> where T: NumLike {
14530	type Output = Power<T>;
14531	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
14532		Power{W: self.V / rhs.per_A.clone()}
14533	}
14534}
14535/// Dividing a Voltage by a InverseCurrent returns a value of type Power
14536impl<T> core::ops::Div<&InverseCurrent<T>> for &Voltage<T> where T: NumLike {
14537	type Output = Power<T>;
14538	fn div(self, rhs: &InverseCurrent<T>) -> Self::Output {
14539		Power{W: self.V.clone() / rhs.per_A.clone()}
14540	}
14541}
14542
14543// Voltage * Time -> MagneticFlux
14544/// Multiplying a Voltage by a Time returns a value of type MagneticFlux
14545impl<T> core::ops::Mul<Time<T>> for Voltage<T> where T: NumLike {
14546	type Output = MagneticFlux<T>;
14547	fn mul(self, rhs: Time<T>) -> Self::Output {
14548		MagneticFlux{Wb: self.V * rhs.s}
14549	}
14550}
14551/// Multiplying a Voltage by a Time returns a value of type MagneticFlux
14552impl<T> core::ops::Mul<Time<T>> for &Voltage<T> where T: NumLike {
14553	type Output = MagneticFlux<T>;
14554	fn mul(self, rhs: Time<T>) -> Self::Output {
14555		MagneticFlux{Wb: self.V.clone() * rhs.s}
14556	}
14557}
14558/// Multiplying a Voltage by a Time returns a value of type MagneticFlux
14559impl<T> core::ops::Mul<&Time<T>> for Voltage<T> where T: NumLike {
14560	type Output = MagneticFlux<T>;
14561	fn mul(self, rhs: &Time<T>) -> Self::Output {
14562		MagneticFlux{Wb: self.V * rhs.s.clone()}
14563	}
14564}
14565/// Multiplying a Voltage by a Time returns a value of type MagneticFlux
14566impl<T> core::ops::Mul<&Time<T>> for &Voltage<T> where T: NumLike {
14567	type Output = MagneticFlux<T>;
14568	fn mul(self, rhs: &Time<T>) -> Self::Output {
14569		MagneticFlux{Wb: self.V.clone() * rhs.s.clone()}
14570	}
14571}
14572
14573// Voltage * Capacitance -> Charge
14574/// Multiplying a Voltage by a Capacitance returns a value of type Charge
14575impl<T> core::ops::Mul<Capacitance<T>> for Voltage<T> where T: NumLike {
14576	type Output = Charge<T>;
14577	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
14578		Charge{C: self.V * rhs.F}
14579	}
14580}
14581/// Multiplying a Voltage by a Capacitance returns a value of type Charge
14582impl<T> core::ops::Mul<Capacitance<T>> for &Voltage<T> where T: NumLike {
14583	type Output = Charge<T>;
14584	fn mul(self, rhs: Capacitance<T>) -> Self::Output {
14585		Charge{C: self.V.clone() * rhs.F}
14586	}
14587}
14588/// Multiplying a Voltage by a Capacitance returns a value of type Charge
14589impl<T> core::ops::Mul<&Capacitance<T>> for Voltage<T> where T: NumLike {
14590	type Output = Charge<T>;
14591	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
14592		Charge{C: self.V * rhs.F.clone()}
14593	}
14594}
14595/// Multiplying a Voltage by a Capacitance returns a value of type Charge
14596impl<T> core::ops::Mul<&Capacitance<T>> for &Voltage<T> where T: NumLike {
14597	type Output = Charge<T>;
14598	fn mul(self, rhs: &Capacitance<T>) -> Self::Output {
14599		Charge{C: self.V.clone() * rhs.F.clone()}
14600	}
14601}
14602
14603// Voltage * Charge -> Energy
14604/// Multiplying a Voltage by a Charge returns a value of type Energy
14605impl<T> core::ops::Mul<Charge<T>> for Voltage<T> where T: NumLike {
14606	type Output = Energy<T>;
14607	fn mul(self, rhs: Charge<T>) -> Self::Output {
14608		Energy{J: self.V * rhs.C}
14609	}
14610}
14611/// Multiplying a Voltage by a Charge returns a value of type Energy
14612impl<T> core::ops::Mul<Charge<T>> for &Voltage<T> where T: NumLike {
14613	type Output = Energy<T>;
14614	fn mul(self, rhs: Charge<T>) -> Self::Output {
14615		Energy{J: self.V.clone() * rhs.C}
14616	}
14617}
14618/// Multiplying a Voltage by a Charge returns a value of type Energy
14619impl<T> core::ops::Mul<&Charge<T>> for Voltage<T> where T: NumLike {
14620	type Output = Energy<T>;
14621	fn mul(self, rhs: &Charge<T>) -> Self::Output {
14622		Energy{J: self.V * rhs.C.clone()}
14623	}
14624}
14625/// Multiplying a Voltage by a Charge returns a value of type Energy
14626impl<T> core::ops::Mul<&Charge<T>> for &Voltage<T> where T: NumLike {
14627	type Output = Energy<T>;
14628	fn mul(self, rhs: &Charge<T>) -> Self::Output {
14629		Energy{J: self.V.clone() * rhs.C.clone()}
14630	}
14631}
14632
14633// Voltage / Charge -> Elastance
14634/// Dividing a Voltage by a Charge returns a value of type Elastance
14635impl<T> core::ops::Div<Charge<T>> for Voltage<T> where T: NumLike {
14636	type Output = Elastance<T>;
14637	fn div(self, rhs: Charge<T>) -> Self::Output {
14638		Elastance{per_F: self.V / rhs.C}
14639	}
14640}
14641/// Dividing a Voltage by a Charge returns a value of type Elastance
14642impl<T> core::ops::Div<Charge<T>> for &Voltage<T> where T: NumLike {
14643	type Output = Elastance<T>;
14644	fn div(self, rhs: Charge<T>) -> Self::Output {
14645		Elastance{per_F: self.V.clone() / rhs.C}
14646	}
14647}
14648/// Dividing a Voltage by a Charge returns a value of type Elastance
14649impl<T> core::ops::Div<&Charge<T>> for Voltage<T> where T: NumLike {
14650	type Output = Elastance<T>;
14651	fn div(self, rhs: &Charge<T>) -> Self::Output {
14652		Elastance{per_F: self.V / rhs.C.clone()}
14653	}
14654}
14655/// Dividing a Voltage by a Charge returns a value of type Elastance
14656impl<T> core::ops::Div<&Charge<T>> for &Voltage<T> where T: NumLike {
14657	type Output = Elastance<T>;
14658	fn div(self, rhs: &Charge<T>) -> Self::Output {
14659		Elastance{per_F: self.V.clone() / rhs.C.clone()}
14660	}
14661}
14662
14663// Voltage * Conductance -> Current
14664/// Multiplying a Voltage by a Conductance returns a value of type Current
14665impl<T> core::ops::Mul<Conductance<T>> for Voltage<T> where T: NumLike {
14666	type Output = Current<T>;
14667	fn mul(self, rhs: Conductance<T>) -> Self::Output {
14668		Current{A: self.V * rhs.S}
14669	}
14670}
14671/// Multiplying a Voltage by a Conductance returns a value of type Current
14672impl<T> core::ops::Mul<Conductance<T>> for &Voltage<T> where T: NumLike {
14673	type Output = Current<T>;
14674	fn mul(self, rhs: Conductance<T>) -> Self::Output {
14675		Current{A: self.V.clone() * rhs.S}
14676	}
14677}
14678/// Multiplying a Voltage by a Conductance returns a value of type Current
14679impl<T> core::ops::Mul<&Conductance<T>> for Voltage<T> where T: NumLike {
14680	type Output = Current<T>;
14681	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
14682		Current{A: self.V * rhs.S.clone()}
14683	}
14684}
14685/// Multiplying a Voltage by a Conductance returns a value of type Current
14686impl<T> core::ops::Mul<&Conductance<T>> for &Voltage<T> where T: NumLike {
14687	type Output = Current<T>;
14688	fn mul(self, rhs: &Conductance<T>) -> Self::Output {
14689		Current{A: self.V.clone() * rhs.S.clone()}
14690	}
14691}
14692
14693// Voltage / Elastance -> Charge
14694/// Dividing a Voltage by a Elastance returns a value of type Charge
14695impl<T> core::ops::Div<Elastance<T>> for Voltage<T> where T: NumLike {
14696	type Output = Charge<T>;
14697	fn div(self, rhs: Elastance<T>) -> Self::Output {
14698		Charge{C: self.V / rhs.per_F}
14699	}
14700}
14701/// Dividing a Voltage by a Elastance returns a value of type Charge
14702impl<T> core::ops::Div<Elastance<T>> for &Voltage<T> where T: NumLike {
14703	type Output = Charge<T>;
14704	fn div(self, rhs: Elastance<T>) -> Self::Output {
14705		Charge{C: self.V.clone() / rhs.per_F}
14706	}
14707}
14708/// Dividing a Voltage by a Elastance returns a value of type Charge
14709impl<T> core::ops::Div<&Elastance<T>> for Voltage<T> where T: NumLike {
14710	type Output = Charge<T>;
14711	fn div(self, rhs: &Elastance<T>) -> Self::Output {
14712		Charge{C: self.V / rhs.per_F.clone()}
14713	}
14714}
14715/// Dividing a Voltage by a Elastance returns a value of type Charge
14716impl<T> core::ops::Div<&Elastance<T>> for &Voltage<T> where T: NumLike {
14717	type Output = Charge<T>;
14718	fn div(self, rhs: &Elastance<T>) -> Self::Output {
14719		Charge{C: self.V.clone() / rhs.per_F.clone()}
14720	}
14721}
14722
14723// Voltage * InverseCharge -> Elastance
14724/// Multiplying a Voltage by a InverseCharge returns a value of type Elastance
14725impl<T> core::ops::Mul<InverseCharge<T>> for Voltage<T> where T: NumLike {
14726	type Output = Elastance<T>;
14727	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
14728		Elastance{per_F: self.V * rhs.per_C}
14729	}
14730}
14731/// Multiplying a Voltage by a InverseCharge returns a value of type Elastance
14732impl<T> core::ops::Mul<InverseCharge<T>> for &Voltage<T> where T: NumLike {
14733	type Output = Elastance<T>;
14734	fn mul(self, rhs: InverseCharge<T>) -> Self::Output {
14735		Elastance{per_F: self.V.clone() * rhs.per_C}
14736	}
14737}
14738/// Multiplying a Voltage by a InverseCharge returns a value of type Elastance
14739impl<T> core::ops::Mul<&InverseCharge<T>> for Voltage<T> where T: NumLike {
14740	type Output = Elastance<T>;
14741	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
14742		Elastance{per_F: self.V * rhs.per_C.clone()}
14743	}
14744}
14745/// Multiplying a Voltage by a InverseCharge returns a value of type Elastance
14746impl<T> core::ops::Mul<&InverseCharge<T>> for &Voltage<T> where T: NumLike {
14747	type Output = Elastance<T>;
14748	fn mul(self, rhs: &InverseCharge<T>) -> Self::Output {
14749		Elastance{per_F: self.V.clone() * rhs.per_C.clone()}
14750	}
14751}
14752
14753// Voltage / InverseCharge -> Energy
14754/// Dividing a Voltage by a InverseCharge returns a value of type Energy
14755impl<T> core::ops::Div<InverseCharge<T>> for Voltage<T> where T: NumLike {
14756	type Output = Energy<T>;
14757	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
14758		Energy{J: self.V / rhs.per_C}
14759	}
14760}
14761/// Dividing a Voltage by a InverseCharge returns a value of type Energy
14762impl<T> core::ops::Div<InverseCharge<T>> for &Voltage<T> where T: NumLike {
14763	type Output = Energy<T>;
14764	fn div(self, rhs: InverseCharge<T>) -> Self::Output {
14765		Energy{J: self.V.clone() / rhs.per_C}
14766	}
14767}
14768/// Dividing a Voltage by a InverseCharge returns a value of type Energy
14769impl<T> core::ops::Div<&InverseCharge<T>> for Voltage<T> where T: NumLike {
14770	type Output = Energy<T>;
14771	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
14772		Energy{J: self.V / rhs.per_C.clone()}
14773	}
14774}
14775/// Dividing a Voltage by a InverseCharge returns a value of type Energy
14776impl<T> core::ops::Div<&InverseCharge<T>> for &Voltage<T> where T: NumLike {
14777	type Output = Energy<T>;
14778	fn div(self, rhs: &InverseCharge<T>) -> Self::Output {
14779		Energy{J: self.V.clone() / rhs.per_C.clone()}
14780	}
14781}
14782
14783// Voltage * InverseMagneticFlux -> Frequency
14784/// Multiplying a Voltage by a InverseMagneticFlux returns a value of type Frequency
14785impl<T> core::ops::Mul<InverseMagneticFlux<T>> for Voltage<T> where T: NumLike {
14786	type Output = Frequency<T>;
14787	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
14788		Frequency{Hz: self.V * rhs.per_Wb}
14789	}
14790}
14791/// Multiplying a Voltage by a InverseMagneticFlux returns a value of type Frequency
14792impl<T> core::ops::Mul<InverseMagneticFlux<T>> for &Voltage<T> where T: NumLike {
14793	type Output = Frequency<T>;
14794	fn mul(self, rhs: InverseMagneticFlux<T>) -> Self::Output {
14795		Frequency{Hz: self.V.clone() * rhs.per_Wb}
14796	}
14797}
14798/// Multiplying a Voltage by a InverseMagneticFlux returns a value of type Frequency
14799impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for Voltage<T> where T: NumLike {
14800	type Output = Frequency<T>;
14801	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
14802		Frequency{Hz: self.V * rhs.per_Wb.clone()}
14803	}
14804}
14805/// Multiplying a Voltage by a InverseMagneticFlux returns a value of type Frequency
14806impl<T> core::ops::Mul<&InverseMagneticFlux<T>> for &Voltage<T> where T: NumLike {
14807	type Output = Frequency<T>;
14808	fn mul(self, rhs: &InverseMagneticFlux<T>) -> Self::Output {
14809		Frequency{Hz: self.V.clone() * rhs.per_Wb.clone()}
14810	}
14811}
14812
14813// Voltage / MagneticFlux -> Frequency
14814/// Dividing a Voltage by a MagneticFlux returns a value of type Frequency
14815impl<T> core::ops::Div<MagneticFlux<T>> for Voltage<T> where T: NumLike {
14816	type Output = Frequency<T>;
14817	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
14818		Frequency{Hz: self.V / rhs.Wb}
14819	}
14820}
14821/// Dividing a Voltage by a MagneticFlux returns a value of type Frequency
14822impl<T> core::ops::Div<MagneticFlux<T>> for &Voltage<T> where T: NumLike {
14823	type Output = Frequency<T>;
14824	fn div(self, rhs: MagneticFlux<T>) -> Self::Output {
14825		Frequency{Hz: self.V.clone() / rhs.Wb}
14826	}
14827}
14828/// Dividing a Voltage by a MagneticFlux returns a value of type Frequency
14829impl<T> core::ops::Div<&MagneticFlux<T>> for Voltage<T> where T: NumLike {
14830	type Output = Frequency<T>;
14831	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
14832		Frequency{Hz: self.V / rhs.Wb.clone()}
14833	}
14834}
14835/// Dividing a Voltage by a MagneticFlux returns a value of type Frequency
14836impl<T> core::ops::Div<&MagneticFlux<T>> for &Voltage<T> where T: NumLike {
14837	type Output = Frequency<T>;
14838	fn div(self, rhs: &MagneticFlux<T>) -> Self::Output {
14839		Frequency{Hz: self.V.clone() / rhs.Wb.clone()}
14840	}
14841}
14842
14843// Voltage / Resistance -> Current
14844/// Dividing a Voltage by a Resistance returns a value of type Current
14845impl<T> core::ops::Div<Resistance<T>> for Voltage<T> where T: NumLike {
14846	type Output = Current<T>;
14847	fn div(self, rhs: Resistance<T>) -> Self::Output {
14848		Current{A: self.V / rhs.Ohm}
14849	}
14850}
14851/// Dividing a Voltage by a Resistance returns a value of type Current
14852impl<T> core::ops::Div<Resistance<T>> for &Voltage<T> where T: NumLike {
14853	type Output = Current<T>;
14854	fn div(self, rhs: Resistance<T>) -> Self::Output {
14855		Current{A: self.V.clone() / rhs.Ohm}
14856	}
14857}
14858/// Dividing a Voltage by a Resistance returns a value of type Current
14859impl<T> core::ops::Div<&Resistance<T>> for Voltage<T> where T: NumLike {
14860	type Output = Current<T>;
14861	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14862		Current{A: self.V / rhs.Ohm.clone()}
14863	}
14864}
14865/// Dividing a Voltage by a Resistance returns a value of type Current
14866impl<T> core::ops::Div<&Resistance<T>> for &Voltage<T> where T: NumLike {
14867	type Output = Current<T>;
14868	fn div(self, rhs: &Resistance<T>) -> Self::Output {
14869		Current{A: self.V.clone() / rhs.Ohm.clone()}
14870	}
14871}
14872
14873// Voltage / Energy -> InverseCharge
14874/// Dividing a Voltage by a Energy returns a value of type InverseCharge
14875impl<T> core::ops::Div<Energy<T>> for Voltage<T> where T: NumLike {
14876	type Output = InverseCharge<T>;
14877	fn div(self, rhs: Energy<T>) -> Self::Output {
14878		InverseCharge{per_C: self.V / rhs.J}
14879	}
14880}
14881/// Dividing a Voltage by a Energy returns a value of type InverseCharge
14882impl<T> core::ops::Div<Energy<T>> for &Voltage<T> where T: NumLike {
14883	type Output = InverseCharge<T>;
14884	fn div(self, rhs: Energy<T>) -> Self::Output {
14885		InverseCharge{per_C: self.V.clone() / rhs.J}
14886	}
14887}
14888/// Dividing a Voltage by a Energy returns a value of type InverseCharge
14889impl<T> core::ops::Div<&Energy<T>> for Voltage<T> where T: NumLike {
14890	type Output = InverseCharge<T>;
14891	fn div(self, rhs: &Energy<T>) -> Self::Output {
14892		InverseCharge{per_C: self.V / rhs.J.clone()}
14893	}
14894}
14895/// Dividing a Voltage by a Energy returns a value of type InverseCharge
14896impl<T> core::ops::Div<&Energy<T>> for &Voltage<T> where T: NumLike {
14897	type Output = InverseCharge<T>;
14898	fn div(self, rhs: &Energy<T>) -> Self::Output {
14899		InverseCharge{per_C: self.V.clone() / rhs.J.clone()}
14900	}
14901}
14902
14903// Voltage / Torque -> InverseCharge
14904/// Dividing a Voltage by a Torque returns a value of type InverseCharge
14905impl<T> core::ops::Div<Torque<T>> for Voltage<T> where T: NumLike {
14906	type Output = InverseCharge<T>;
14907	fn div(self, rhs: Torque<T>) -> Self::Output {
14908		InverseCharge{per_C: self.V / rhs.Nm}
14909	}
14910}
14911/// Dividing a Voltage by a Torque returns a value of type InverseCharge
14912impl<T> core::ops::Div<Torque<T>> for &Voltage<T> where T: NumLike {
14913	type Output = InverseCharge<T>;
14914	fn div(self, rhs: Torque<T>) -> Self::Output {
14915		InverseCharge{per_C: self.V.clone() / rhs.Nm}
14916	}
14917}
14918/// Dividing a Voltage by a Torque returns a value of type InverseCharge
14919impl<T> core::ops::Div<&Torque<T>> for Voltage<T> where T: NumLike {
14920	type Output = InverseCharge<T>;
14921	fn div(self, rhs: &Torque<T>) -> Self::Output {
14922		InverseCharge{per_C: self.V / rhs.Nm.clone()}
14923	}
14924}
14925/// Dividing a Voltage by a Torque returns a value of type InverseCharge
14926impl<T> core::ops::Div<&Torque<T>> for &Voltage<T> where T: NumLike {
14927	type Output = InverseCharge<T>;
14928	fn div(self, rhs: &Torque<T>) -> Self::Output {
14929		InverseCharge{per_C: self.V.clone() / rhs.Nm.clone()}
14930	}
14931}
14932
14933// Voltage / Frequency -> MagneticFlux
14934/// Dividing a Voltage by a Frequency returns a value of type MagneticFlux
14935impl<T> core::ops::Div<Frequency<T>> for Voltage<T> where T: NumLike {
14936	type Output = MagneticFlux<T>;
14937	fn div(self, rhs: Frequency<T>) -> Self::Output {
14938		MagneticFlux{Wb: self.V / rhs.Hz}
14939	}
14940}
14941/// Dividing a Voltage by a Frequency returns a value of type MagneticFlux
14942impl<T> core::ops::Div<Frequency<T>> for &Voltage<T> where T: NumLike {
14943	type Output = MagneticFlux<T>;
14944	fn div(self, rhs: Frequency<T>) -> Self::Output {
14945		MagneticFlux{Wb: self.V.clone() / rhs.Hz}
14946	}
14947}
14948/// Dividing a Voltage by a Frequency returns a value of type MagneticFlux
14949impl<T> core::ops::Div<&Frequency<T>> for Voltage<T> where T: NumLike {
14950	type Output = MagneticFlux<T>;
14951	fn div(self, rhs: &Frequency<T>) -> Self::Output {
14952		MagneticFlux{Wb: self.V / rhs.Hz.clone()}
14953	}
14954}
14955/// Dividing a Voltage by a Frequency returns a value of type MagneticFlux
14956impl<T> core::ops::Div<&Frequency<T>> for &Voltage<T> where T: NumLike {
14957	type Output = MagneticFlux<T>;
14958	fn div(self, rhs: &Frequency<T>) -> Self::Output {
14959		MagneticFlux{Wb: self.V.clone() / rhs.Hz.clone()}
14960	}
14961}
14962
14963// Voltage * InverseEnergy -> InverseCharge
14964/// Multiplying a Voltage by a InverseEnergy returns a value of type InverseCharge
14965impl<T> core::ops::Mul<InverseEnergy<T>> for Voltage<T> where T: NumLike {
14966	type Output = InverseCharge<T>;
14967	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
14968		InverseCharge{per_C: self.V * rhs.per_J}
14969	}
14970}
14971/// Multiplying a Voltage by a InverseEnergy returns a value of type InverseCharge
14972impl<T> core::ops::Mul<InverseEnergy<T>> for &Voltage<T> where T: NumLike {
14973	type Output = InverseCharge<T>;
14974	fn mul(self, rhs: InverseEnergy<T>) -> Self::Output {
14975		InverseCharge{per_C: self.V.clone() * rhs.per_J}
14976	}
14977}
14978/// Multiplying a Voltage by a InverseEnergy returns a value of type InverseCharge
14979impl<T> core::ops::Mul<&InverseEnergy<T>> for Voltage<T> where T: NumLike {
14980	type Output = InverseCharge<T>;
14981	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
14982		InverseCharge{per_C: self.V * rhs.per_J.clone()}
14983	}
14984}
14985/// Multiplying a Voltage by a InverseEnergy returns a value of type InverseCharge
14986impl<T> core::ops::Mul<&InverseEnergy<T>> for &Voltage<T> where T: NumLike {
14987	type Output = InverseCharge<T>;
14988	fn mul(self, rhs: &InverseEnergy<T>) -> Self::Output {
14989		InverseCharge{per_C: self.V.clone() * rhs.per_J.clone()}
14990	}
14991}
14992
14993// Voltage * InverseTorque -> InverseCharge
14994/// Multiplying a Voltage by a InverseTorque returns a value of type InverseCharge
14995impl<T> core::ops::Mul<InverseTorque<T>> for Voltage<T> where T: NumLike {
14996	type Output = InverseCharge<T>;
14997	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
14998		InverseCharge{per_C: self.V * rhs.per_Nm}
14999	}
15000}
15001/// Multiplying a Voltage by a InverseTorque returns a value of type InverseCharge
15002impl<T> core::ops::Mul<InverseTorque<T>> for &Voltage<T> where T: NumLike {
15003	type Output = InverseCharge<T>;
15004	fn mul(self, rhs: InverseTorque<T>) -> Self::Output {
15005		InverseCharge{per_C: self.V.clone() * rhs.per_Nm}
15006	}
15007}
15008/// Multiplying a Voltage by a InverseTorque returns a value of type InverseCharge
15009impl<T> core::ops::Mul<&InverseTorque<T>> for Voltage<T> where T: NumLike {
15010	type Output = InverseCharge<T>;
15011	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
15012		InverseCharge{per_C: self.V * rhs.per_Nm.clone()}
15013	}
15014}
15015/// Multiplying a Voltage by a InverseTorque returns a value of type InverseCharge
15016impl<T> core::ops::Mul<&InverseTorque<T>> for &Voltage<T> where T: NumLike {
15017	type Output = InverseCharge<T>;
15018	fn mul(self, rhs: &InverseTorque<T>) -> Self::Output {
15019		InverseCharge{per_C: self.V.clone() * rhs.per_Nm.clone()}
15020	}
15021}
15022
15023// Voltage * InversePower -> InverseCurrent
15024/// Multiplying a Voltage by a InversePower returns a value of type InverseCurrent
15025impl<T> core::ops::Mul<InversePower<T>> for Voltage<T> where T: NumLike {
15026	type Output = InverseCurrent<T>;
15027	fn mul(self, rhs: InversePower<T>) -> Self::Output {
15028		InverseCurrent{per_A: self.V * rhs.per_W}
15029	}
15030}
15031/// Multiplying a Voltage by a InversePower returns a value of type InverseCurrent
15032impl<T> core::ops::Mul<InversePower<T>> for &Voltage<T> where T: NumLike {
15033	type Output = InverseCurrent<T>;
15034	fn mul(self, rhs: InversePower<T>) -> Self::Output {
15035		InverseCurrent{per_A: self.V.clone() * rhs.per_W}
15036	}
15037}
15038/// Multiplying a Voltage by a InversePower returns a value of type InverseCurrent
15039impl<T> core::ops::Mul<&InversePower<T>> for Voltage<T> where T: NumLike {
15040	type Output = InverseCurrent<T>;
15041	fn mul(self, rhs: &InversePower<T>) -> Self::Output {
15042		InverseCurrent{per_A: self.V * rhs.per_W.clone()}
15043	}
15044}
15045/// Multiplying a Voltage by a InversePower returns a value of type InverseCurrent
15046impl<T> core::ops::Mul<&InversePower<T>> for &Voltage<T> where T: NumLike {
15047	type Output = InverseCurrent<T>;
15048	fn mul(self, rhs: &InversePower<T>) -> Self::Output {
15049		InverseCurrent{per_A: self.V.clone() * rhs.per_W.clone()}
15050	}
15051}
15052
15053// Voltage / Power -> InverseCurrent
15054/// Dividing a Voltage by a Power returns a value of type InverseCurrent
15055impl<T> core::ops::Div<Power<T>> for Voltage<T> where T: NumLike {
15056	type Output = InverseCurrent<T>;
15057	fn div(self, rhs: Power<T>) -> Self::Output {
15058		InverseCurrent{per_A: self.V / rhs.W}
15059	}
15060}
15061/// Dividing a Voltage by a Power returns a value of type InverseCurrent
15062impl<T> core::ops::Div<Power<T>> for &Voltage<T> where T: NumLike {
15063	type Output = InverseCurrent<T>;
15064	fn div(self, rhs: Power<T>) -> Self::Output {
15065		InverseCurrent{per_A: self.V.clone() / rhs.W}
15066	}
15067}
15068/// Dividing a Voltage by a Power returns a value of type InverseCurrent
15069impl<T> core::ops::Div<&Power<T>> for Voltage<T> where T: NumLike {
15070	type Output = InverseCurrent<T>;
15071	fn div(self, rhs: &Power<T>) -> Self::Output {
15072		InverseCurrent{per_A: self.V / rhs.W.clone()}
15073	}
15074}
15075/// Dividing a Voltage by a Power returns a value of type InverseCurrent
15076impl<T> core::ops::Div<&Power<T>> for &Voltage<T> where T: NumLike {
15077	type Output = InverseCurrent<T>;
15078	fn div(self, rhs: &Power<T>) -> Self::Output {
15079		InverseCurrent{per_A: self.V.clone() / rhs.W.clone()}
15080	}
15081}
15082
15083// 1/Voltage -> InverseVoltage
15084/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15085impl<T> core::ops::Div<Voltage<T>> for f64 where T: NumLike+From<f64> {
15086	type Output = InverseVoltage<T>;
15087	fn div(self, rhs: Voltage<T>) -> Self::Output {
15088		InverseVoltage{per_V: T::from(self) / rhs.V}
15089	}
15090}
15091/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15092impl<T> core::ops::Div<Voltage<T>> for &f64 where T: NumLike+From<f64> {
15093	type Output = InverseVoltage<T>;
15094	fn div(self, rhs: Voltage<T>) -> Self::Output {
15095		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15096	}
15097}
15098/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15099impl<T> core::ops::Div<&Voltage<T>> for f64 where T: NumLike+From<f64> {
15100	type Output = InverseVoltage<T>;
15101	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15102		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15103	}
15104}
15105/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15106impl<T> core::ops::Div<&Voltage<T>> for &f64 where T: NumLike+From<f64> {
15107	type Output = InverseVoltage<T>;
15108	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15109		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15110	}
15111}
15112
15113// 1/Voltage -> InverseVoltage
15114/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15115impl<T> core::ops::Div<Voltage<T>> for f32 where T: NumLike+From<f32> {
15116	type Output = InverseVoltage<T>;
15117	fn div(self, rhs: Voltage<T>) -> Self::Output {
15118		InverseVoltage{per_V: T::from(self) / rhs.V}
15119	}
15120}
15121/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15122impl<T> core::ops::Div<Voltage<T>> for &f32 where T: NumLike+From<f32> {
15123	type Output = InverseVoltage<T>;
15124	fn div(self, rhs: Voltage<T>) -> Self::Output {
15125		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15126	}
15127}
15128/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15129impl<T> core::ops::Div<&Voltage<T>> for f32 where T: NumLike+From<f32> {
15130	type Output = InverseVoltage<T>;
15131	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15132		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15133	}
15134}
15135/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15136impl<T> core::ops::Div<&Voltage<T>> for &f32 where T: NumLike+From<f32> {
15137	type Output = InverseVoltage<T>;
15138	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15139		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15140	}
15141}
15142
15143// 1/Voltage -> InverseVoltage
15144/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15145impl<T> core::ops::Div<Voltage<T>> for i64 where T: NumLike+From<i64> {
15146	type Output = InverseVoltage<T>;
15147	fn div(self, rhs: Voltage<T>) -> Self::Output {
15148		InverseVoltage{per_V: T::from(self) / rhs.V}
15149	}
15150}
15151/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15152impl<T> core::ops::Div<Voltage<T>> for &i64 where T: NumLike+From<i64> {
15153	type Output = InverseVoltage<T>;
15154	fn div(self, rhs: Voltage<T>) -> Self::Output {
15155		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15156	}
15157}
15158/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15159impl<T> core::ops::Div<&Voltage<T>> for i64 where T: NumLike+From<i64> {
15160	type Output = InverseVoltage<T>;
15161	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15162		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15163	}
15164}
15165/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15166impl<T> core::ops::Div<&Voltage<T>> for &i64 where T: NumLike+From<i64> {
15167	type Output = InverseVoltage<T>;
15168	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15169		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15170	}
15171}
15172
15173// 1/Voltage -> InverseVoltage
15174/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15175impl<T> core::ops::Div<Voltage<T>> for i32 where T: NumLike+From<i32> {
15176	type Output = InverseVoltage<T>;
15177	fn div(self, rhs: Voltage<T>) -> Self::Output {
15178		InverseVoltage{per_V: T::from(self) / rhs.V}
15179	}
15180}
15181/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15182impl<T> core::ops::Div<Voltage<T>> for &i32 where T: NumLike+From<i32> {
15183	type Output = InverseVoltage<T>;
15184	fn div(self, rhs: Voltage<T>) -> Self::Output {
15185		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15186	}
15187}
15188/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15189impl<T> core::ops::Div<&Voltage<T>> for i32 where T: NumLike+From<i32> {
15190	type Output = InverseVoltage<T>;
15191	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15192		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15193	}
15194}
15195/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15196impl<T> core::ops::Div<&Voltage<T>> for &i32 where T: NumLike+From<i32> {
15197	type Output = InverseVoltage<T>;
15198	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15199		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15200	}
15201}
15202
15203// 1/Voltage -> InverseVoltage
15204/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15205#[cfg(feature="num-bigfloat")]
15206impl<T> core::ops::Div<Voltage<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
15207	type Output = InverseVoltage<T>;
15208	fn div(self, rhs: Voltage<T>) -> Self::Output {
15209		InverseVoltage{per_V: T::from(self) / rhs.V}
15210	}
15211}
15212/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15213#[cfg(feature="num-bigfloat")]
15214impl<T> core::ops::Div<Voltage<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
15215	type Output = InverseVoltage<T>;
15216	fn div(self, rhs: Voltage<T>) -> Self::Output {
15217		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15218	}
15219}
15220/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15221#[cfg(feature="num-bigfloat")]
15222impl<T> core::ops::Div<&Voltage<T>> for num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
15223	type Output = InverseVoltage<T>;
15224	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15225		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15226	}
15227}
15228/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15229#[cfg(feature="num-bigfloat")]
15230impl<T> core::ops::Div<&Voltage<T>> for &num_bigfloat::BigFloat where T: NumLike+From<num_bigfloat::BigFloat> {
15231	type Output = InverseVoltage<T>;
15232	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15233		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15234	}
15235}
15236
15237// 1/Voltage -> InverseVoltage
15238/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15239#[cfg(feature="num-complex")]
15240impl<T> core::ops::Div<Voltage<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
15241	type Output = InverseVoltage<T>;
15242	fn div(self, rhs: Voltage<T>) -> Self::Output {
15243		InverseVoltage{per_V: T::from(self) / rhs.V}
15244	}
15245}
15246/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15247#[cfg(feature="num-complex")]
15248impl<T> core::ops::Div<Voltage<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
15249	type Output = InverseVoltage<T>;
15250	fn div(self, rhs: Voltage<T>) -> Self::Output {
15251		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15252	}
15253}
15254/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15255#[cfg(feature="num-complex")]
15256impl<T> core::ops::Div<&Voltage<T>> for num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
15257	type Output = InverseVoltage<T>;
15258	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15259		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15260	}
15261}
15262/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15263#[cfg(feature="num-complex")]
15264impl<T> core::ops::Div<&Voltage<T>> for &num_complex::Complex32 where T: NumLike+From<num_complex::Complex32> {
15265	type Output = InverseVoltage<T>;
15266	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15267		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15268	}
15269}
15270
15271// 1/Voltage -> InverseVoltage
15272/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15273#[cfg(feature="num-complex")]
15274impl<T> core::ops::Div<Voltage<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
15275	type Output = InverseVoltage<T>;
15276	fn div(self, rhs: Voltage<T>) -> Self::Output {
15277		InverseVoltage{per_V: T::from(self) / rhs.V}
15278	}
15279}
15280/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15281#[cfg(feature="num-complex")]
15282impl<T> core::ops::Div<Voltage<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
15283	type Output = InverseVoltage<T>;
15284	fn div(self, rhs: Voltage<T>) -> Self::Output {
15285		InverseVoltage{per_V: T::from(self.clone()) / rhs.V}
15286	}
15287}
15288/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15289#[cfg(feature="num-complex")]
15290impl<T> core::ops::Div<&Voltage<T>> for num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
15291	type Output = InverseVoltage<T>;
15292	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15293		InverseVoltage{per_V: T::from(self) / rhs.V.clone()}
15294	}
15295}
15296/// Dividing a scalar value by a Voltage unit value returns a value of type InverseVoltage
15297#[cfg(feature="num-complex")]
15298impl<T> core::ops::Div<&Voltage<T>> for &num_complex::Complex64 where T: NumLike+From<num_complex::Complex64> {
15299	type Output = InverseVoltage<T>;
15300	fn div(self, rhs: &Voltage<T>) -> Self::Output {
15301		InverseVoltage{per_V: T::from(self.clone()) / rhs.V.clone()}
15302	}
15303}
15304
15305
15306
simple_si_units/electromagnetic.rs

simple_si_units/
electromagnetic.rs
