L0 = <http://www.simantics.org/Layer0-1.1>
DATA = <http://www.simantics.org/Datatypes-1.1>
SI = DATA.SI : L0.Library
    L0.HasResourceClass "org.simantics.datatypes.SIResource"

SI.Unit <T L0.Entity

// SI base units

SI.TeraMetre <T SI.Unit
SI.TeraMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tm")
SI.TeraMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tm")

SI.GigaMetre <T SI.Unit
SI.GigaMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gm")
SI.GigaMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gm")

SI.MegaMetre <T SI.Unit
SI.MegaMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mm")
SI.MegaMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mm")

SI.KiloMetre <T SI.Unit
SI.KiloMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="km")
SI.KiloMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="km")

SI.HectoMetre <T SI.Unit
SI.HectoMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hm")
SI.HectoMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hm")

SI.Metre <T SI.Unit
SI.Metre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="m")
SI.Metre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="m")

SI.CentiMetre <T SI.Unit
SI.CentiMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cm")
SI.CentiMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cm")

SI.MilliMetre <T SI.Unit
SI.MilliMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mm")
SI.MilliMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mm")

SI.MicroMetre <T SI.Unit
SI.MicroMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="um")
SI.MicroMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="um")

SI.Teragram <T SI.Unit
SI.Teragram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tg")
SI.Teragram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tg")

SI.Gigagram <T SI.Unit
SI.Gigagram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gg")
SI.Gigagram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gg")

SI.Megagram <T SI.Unit
SI.Megagram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mg")
SI.Megagram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mg")

SI.Kilogram <T SI.Unit
SI.Kilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kg")
SI.Kilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kg")

SI.Hectogram <T SI.Unit
SI.Hectogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hg")
SI.Hectogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hg")

SI.gram <T SI.Unit
SI.gram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="g")
SI.gram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="g")

SI.Centigram <T SI.Unit
SI.Centigram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cg")
SI.Centigram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cg")

SI.Milligram <T SI.Unit
SI.Milligram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mg")
SI.Milligram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mg")

SI.Microgram <T SI.Unit
SI.Microgram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ug")
SI.Microgram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ug")

SI.TeraSecond <T SI.Unit
SI.TeraSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Ts")
SI.TeraSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Ts")

SI.GigaSecond <T SI.Unit
SI.GigaSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gs")
SI.GigaSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gs")

SI.MegaSecond <T SI.Unit
SI.MegaSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Ms")
SI.MegaSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Ms")

SI.KiloSecond <T SI.Unit
SI.KiloSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ks")
SI.KiloSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ks")

SI.HectoSecond <T SI.Unit
SI.HectoSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hs")
SI.HectoSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hs")

SI.Second <T SI.Unit
SI.Second.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="s")
SI.Second.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="s")

SI.CentiSecond <T SI.Unit
SI.CentiSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cs")
SI.CentiSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cs")

SI.MilliSecond <T SI.Unit
SI.MilliSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ms")
SI.MilliSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ms")

SI.MicroSecond <T SI.Unit
SI.MicroSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="us")
SI.MicroSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="us")

SI.TeraAmpere <T SI.Unit
SI.TeraAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TA")
SI.TeraAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TA")

SI.GigaAmpere <T SI.Unit
SI.GigaAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GA")
SI.GigaAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GA")

SI.MegaAmpere <T SI.Unit
SI.MegaAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MA")
SI.MegaAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MA")

SI.KiloAmpere <T SI.Unit
SI.KiloAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kA")
SI.KiloAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kA")

SI.HectoAmpere <T SI.Unit
SI.HectoAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hA")
SI.HectoAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hA")

SI.Ampere <T SI.Unit
SI.Ampere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="A")
SI.Ampere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="A")

SI.CentiAmpere <T SI.Unit
SI.CentiAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cA")
SI.CentiAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cA")

SI.MilliAmpere <T SI.Unit
SI.MilliAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mA")
SI.MilliAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mA")

SI.MicroAmpere <T SI.Unit
SI.MicroAmpere.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uA")
SI.MicroAmpere.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uA")

SI.TeraKelvin <T SI.Unit
SI.TeraKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TK")
SI.TeraKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TK")

SI.GigaKelvin <T SI.Unit
SI.GigaKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GK")
SI.GigaKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GK")

SI.MegaKelvin <T SI.Unit
SI.MegaKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MK")
SI.MegaKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MK")

SI.KiloKelvin <T SI.Unit
SI.KiloKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kK")
SI.KiloKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kK")

SI.HectoKelvin <T SI.Unit
SI.HectoKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hK")
SI.HectoKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hK")

SI.Kelvin <T SI.Unit
SI.Kelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="K")
SI.Kelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="K")

SI.CentiKelvin <T SI.Unit
SI.CentiKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cK")
SI.CentiKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cK")

SI.MilliKelvin <T SI.Unit
SI.MilliKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mK")
SI.MilliKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mK")

SI.MicroKelvin <T SI.Unit
SI.MicroKelvin.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uK")
SI.MicroKelvin.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uK")

SI.TeraCandela <T SI.Unit
SI.TeraCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tcd")
SI.TeraCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tcd")

SI.GigaCandela <T SI.Unit
SI.GigaCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gcd")
SI.GigaCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gcd")

SI.MegaCandela <T SI.Unit
SI.MegaCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mcd")
SI.MegaCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mcd")

SI.KiloCandela <T SI.Unit
SI.KiloCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kcd")
SI.KiloCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kcd")

SI.HectoCandela <T SI.Unit
SI.HectoCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hcd")
SI.HectoCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hcd")

SI.Candela <T SI.Unit
SI.Candela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cd")
SI.Candela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cd")

SI.CentiCandela <T SI.Unit
SI.CentiCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ccd")
SI.CentiCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ccd")

SI.MilliCandela <T SI.Unit
SI.MilliCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mcd")
SI.MilliCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mcd")

SI.MicroCandela <T SI.Unit
SI.MicroCandela.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ucd")
SI.MicroCandela.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ucd")

SI.TeraMole <T SI.Unit
SI.TeraMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tmol")
SI.TeraMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tmol")

SI.GigaMole <T SI.Unit
SI.GigaMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gmol")
SI.GigaMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gmol")

SI.MegaMole <T SI.Unit
SI.MegaMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mmol")
SI.MegaMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mmol")

SI.KiloMole <T SI.Unit
SI.KiloMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kmol")
SI.KiloMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kmol")

SI.HectoMole <T SI.Unit
SI.HectoMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hmol")
SI.HectoMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hmol")

SI.Mole <T SI.Unit
SI.Mole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mol")
SI.Mole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mol")

SI.CentiMole <T SI.Unit
SI.CentiMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cmol")
SI.CentiMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cmol")

SI.MilliMole <T SI.Unit
SI.MilliMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mmol")
SI.MilliMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mmol")

SI.MicroMole <T SI.Unit
SI.MicroMole.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="umol")
SI.MicroMole.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="umol")

// SI derived units

SI.TeraHertz <T SI.Unit
SI.TeraHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Thz")
SI.TeraHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Thz")

SI.GigaHertz <T SI.Unit
SI.GigaHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Ghz")
SI.GigaHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Ghz")

SI.MegaHertz <T SI.Unit
SI.MegaHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mhz")
SI.MegaHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mhz")

SI.KiloHertz <T SI.Unit
SI.KiloHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="khz")
SI.KiloHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="khz")

SI.HectoHertz <T SI.Unit
SI.HectoHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hhz")
SI.HectoHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hhz")

SI.Hertz <T SI.Unit
SI.Hertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hz")
SI.Hertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hz")

SI.CentiHertz <T SI.Unit
SI.CentiHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="chz")
SI.CentiHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="chz")

SI.MilliHertz <T SI.Unit
SI.MilliHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mhz")
SI.MilliHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mhz")

SI.MicroHertz <T SI.Unit
SI.MicroHertz.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uhz")
SI.MicroHertz.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uhz")

SI.TeraRadian <T SI.Unit
SI.TeraRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Trad")
SI.TeraRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Trad")

SI.GigaRadian <T SI.Unit
SI.GigaRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Grad")
SI.GigaRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Grad")

SI.MegaRadian <T SI.Unit
SI.MegaRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mrad")
SI.MegaRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mrad")

SI.KiloRadian <T SI.Unit
SI.KiloRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="krad")
SI.KiloRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="krad")

SI.HectoRadian <T SI.Unit
SI.HectoRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hrad")
SI.HectoRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hrad")

SI.Radian <T SI.Unit
SI.Radian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="rad")
SI.Radian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="rad")

SI.CentiRadian <T SI.Unit
SI.CentiRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="crad")
SI.CentiRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="crad")

SI.MilliRadian <T SI.Unit
SI.MilliRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mrad")
SI.MilliRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mrad")

SI.MicroRadian <T SI.Unit
SI.MicroRadian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="urad")
SI.MicroRadian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="urad")

SI.TeraSteradian <T SI.Unit
SI.TeraSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tsr")
SI.TeraSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tsr")

SI.GigaSteradian <T SI.Unit
SI.GigaSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gsr")
SI.GigaSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gsr")

SI.MegaSteradian <T SI.Unit
SI.MegaSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Msr")
SI.MegaSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Msr")

SI.KiloSteradian <T SI.Unit
SI.KiloSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ksr")
SI.KiloSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ksr")

SI.HectoSteradian <T SI.Unit
SI.HectoSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hsr")
SI.HectoSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hsr")

SI.Steradian <T SI.Unit
SI.Steradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="sr")
SI.Steradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="sr")

SI.CentiSteradian <T SI.Unit
SI.CentiSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="csr")
SI.CentiSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="csr")

SI.MilliSteradian <T SI.Unit
SI.MilliSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="msr")
SI.MilliSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="msr")

SI.MicroSteradian <T SI.Unit
SI.MicroSteradian.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="usr")
SI.MicroSteradian.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="usr")

SI.TeraNewton <T SI.Unit
SI.TeraNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TN")
SI.TeraNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TN")

SI.GigaNewton <T SI.Unit
SI.GigaNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GN")
SI.GigaNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GN")

SI.MegaNewton <T SI.Unit
SI.MegaNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MN")
SI.MegaNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MN")

SI.KiloNewton <T SI.Unit
SI.KiloNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kN")
SI.KiloNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kN")

SI.HectoNewton <T SI.Unit
SI.HectoNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hN")
SI.HectoNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hN")

SI.Newton <T SI.Unit
SI.Newton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="N")
SI.Newton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="N")

SI.CentiNewton <T SI.Unit
SI.CentiNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cN")
SI.CentiNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cN")

SI.MilliNewton <T SI.Unit
SI.MilliNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mN")
SI.MilliNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mN")

SI.MicroNewton <T SI.Unit
SI.MicroNewton.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uN")
SI.MicroNewton.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uN")

SI.TeraPascal <T SI.Unit
SI.TeraPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TPa")
SI.TeraPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TPa")

SI.GigaPascal <T SI.Unit
SI.GigaPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GPa")
SI.GigaPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GPa")

SI.MegaPascal <T SI.Unit
SI.MegaPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MPa")
SI.MegaPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MPa")

SI.KiloPascal <T SI.Unit
SI.KiloPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kPa")
SI.KiloPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kPa")

SI.HectoPascal <T SI.Unit
SI.HectoPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hPa")
SI.HectoPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hPa")

SI.Pascal <T SI.Unit
SI.Pascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Pa")
SI.Pascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Pa")

SI.CentiPascal <T SI.Unit
SI.CentiPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cPa")
SI.CentiPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cPa")

SI.MilliPascal <T SI.Unit
SI.MilliPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mPa")
SI.MilliPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mPa")

SI.MicroPascal <T SI.Unit
SI.MicroPascal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uPa")
SI.MicroPascal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uPa")

SI.TeraJoule <T SI.Unit
SI.TeraJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TJ")
SI.TeraJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TJ")

SI.GigaJoule <T SI.Unit
SI.GigaJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GJ")
SI.GigaJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GJ")

SI.MegaJoule <T SI.Unit
SI.MegaJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MJ")
SI.MegaJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MJ")

SI.KiloJoule <T SI.Unit
SI.KiloJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kJ")
SI.KiloJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kJ")

SI.HectoJoule <T SI.Unit
SI.HectoJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hJ")
SI.HectoJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hJ")

SI.Joule <T SI.Unit
SI.Joule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="J")
SI.Joule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="J")

SI.CentiJoule <T SI.Unit
SI.CentiJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cJ")
SI.CentiJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cJ")

SI.MilliJoule <T SI.Unit
SI.MilliJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mJ")
SI.MilliJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mJ")

SI.MicroJoule <T SI.Unit
SI.MicroJoule.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uJ")
SI.MicroJoule.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uJ")

SI.TeraWatt <T SI.Unit
SI.TeraWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TW")
SI.TeraWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TW")

SI.GigaWatt <T SI.Unit
SI.GigaWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GW")
SI.GigaWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GW")

SI.MegaWatt <T SI.Unit
SI.MegaWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MW")
SI.MegaWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MW")

SI.KiloWatt <T SI.Unit
SI.KiloWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kW")
SI.KiloWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kW")

SI.HectoWatt <T SI.Unit
SI.HectoWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hW")
SI.HectoWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hW")

SI.Watt <T SI.Unit
SI.Watt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="W")
SI.Watt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="W")

SI.CentiWatt <T SI.Unit
SI.CentiWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cW")
SI.CentiWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cW")

SI.MilliWatt <T SI.Unit
SI.MilliWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mW")
SI.MilliWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mW")

SI.MicroWatt <T SI.Unit
SI.MicroWatt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uW")
SI.MicroWatt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uW")

SI.TeraCoulomb <T SI.Unit
SI.TeraCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TC")
SI.TeraCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TC")

SI.GigaCoulomb <T SI.Unit
SI.GigaCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GC")
SI.GigaCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GC")

SI.MegaCoulomb <T SI.Unit
SI.MegaCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MC")
SI.MegaCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MC")

SI.KiloCoulomb <T SI.Unit
SI.KiloCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kC")
SI.KiloCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kC")

SI.HectoCoulomb <T SI.Unit
SI.HectoCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hC")
SI.HectoCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hC")

SI.Coulomb <T SI.Unit
SI.Coulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="C")
SI.Coulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="C")

SI.CentiCoulomb <T SI.Unit
SI.CentiCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cC")
SI.CentiCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cC")

SI.MilliCoulomb <T SI.Unit
SI.MilliCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mC")
SI.MilliCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mC")

SI.MicroCoulomb <T SI.Unit
SI.MicroCoulomb.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uC")
SI.MicroCoulomb.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uC")

SI.TeraVolt <T SI.Unit
SI.TeraVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TV")
SI.TeraVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TV")

SI.GigaVolt <T SI.Unit
SI.GigaVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GV")
SI.GigaVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GV")

SI.MegaVolt <T SI.Unit
SI.MegaVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MV")
SI.MegaVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MV")

SI.KiloVolt <T SI.Unit
SI.KiloVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kV")
SI.KiloVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kV")

SI.HectoVolt <T SI.Unit
SI.HectoVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hV")
SI.HectoVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hV")

SI.Volt <T SI.Unit
SI.Volt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="V")
SI.Volt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="V")

SI.CentiVolt <T SI.Unit
SI.CentiVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cV")
SI.CentiVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cV")

SI.MilliVolt <T SI.Unit
SI.MilliVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mV")
SI.MilliVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mV")

SI.MicroVolt <T SI.Unit
SI.MicroVolt.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uV")
SI.MicroVolt.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uV")

SI.TeraFarad <T SI.Unit
SI.TeraFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TF")
SI.TeraFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TF")

SI.GigaFarad <T SI.Unit
SI.GigaFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GF")
SI.GigaFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GF")

SI.MegaFarad <T SI.Unit
SI.MegaFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MF")
SI.MegaFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MF")

SI.KiloFarad <T SI.Unit
SI.KiloFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kF")
SI.KiloFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kF")

SI.HectoFarad <T SI.Unit
SI.HectoFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hF")
SI.HectoFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hF")

SI.Farad <T SI.Unit
SI.Farad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="F")
SI.Farad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="F")

SI.CentiFarad <T SI.Unit
SI.CentiFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cF")
SI.CentiFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cF")

SI.MilliFarad <T SI.Unit
SI.MilliFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mF")
SI.MilliFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mF")

SI.MicroFarad <T SI.Unit
SI.MicroFarad.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uF")
SI.MicroFarad.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uF")

SI.TeraOhm <T SI.Unit
SI.TeraOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tohm")
SI.TeraOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tohm")

SI.GigaOhm <T SI.Unit
SI.GigaOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gohm")
SI.GigaOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gohm")

SI.MegaOhm <T SI.Unit
SI.MegaOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mohm")
SI.MegaOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mohm")

SI.KiloOhm <T SI.Unit
SI.KiloOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kohm")
SI.KiloOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kohm")

SI.HectoOhm <T SI.Unit
SI.HectoOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hohm")
SI.HectoOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hohm")

SI.Ohm <T SI.Unit
SI.Ohm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ohm")
SI.Ohm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ohm")

SI.CentiOhm <T SI.Unit
SI.CentiOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cohm")
SI.CentiOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cohm")

SI.MilliOhm <T SI.Unit
SI.MilliOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mohm")
SI.MilliOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mohm")

SI.MicroOhm <T SI.Unit
SI.MicroOhm.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uohm")
SI.MicroOhm.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uohm")

SI.TeraSiemens <T SI.Unit
SI.TeraSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TS")
SI.TeraSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TS")

SI.GigaSiemens <T SI.Unit
SI.GigaSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GS")
SI.GigaSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GS")

SI.MegaSiemens <T SI.Unit
SI.MegaSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MS")
SI.MegaSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MS")

SI.KiloSiemens <T SI.Unit
SI.KiloSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kS")
SI.KiloSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kS")

SI.HectoSiemens <T SI.Unit
SI.HectoSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hS")
SI.HectoSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hS")

SI.Siemens <T SI.Unit
SI.Siemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="S")
SI.Siemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="S")

SI.CentiSiemens <T SI.Unit
SI.CentiSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cS")
SI.CentiSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cS")

SI.MilliSiemens <T SI.Unit
SI.MilliSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mS")
SI.MilliSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mS")

SI.MicroSiemens <T SI.Unit
SI.MicroSiemens.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uS")
SI.MicroSiemens.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uS")

SI.TeraWeber <T SI.Unit
SI.TeraWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TWb")
SI.TeraWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TWb")

SI.GigaWeber <T SI.Unit
SI.GigaWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GWb")
SI.GigaWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GWb")

SI.MegaWeber <T SI.Unit
SI.MegaWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MWb")
SI.MegaWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MWb")

SI.KiloWeber <T SI.Unit
SI.KiloWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kWb")
SI.KiloWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kWb")

SI.HectoWeber <T SI.Unit
SI.HectoWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hWb")
SI.HectoWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hWb")

SI.Weber <T SI.Unit
SI.Weber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Wb")
SI.Weber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Wb")

SI.CentiWeber <T SI.Unit
SI.CentiWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cWb")
SI.CentiWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cWb")

SI.MilliWeber <T SI.Unit
SI.MilliWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mWb")
SI.MilliWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mWb")

SI.MicroWeber <T SI.Unit
SI.MicroWeber.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uWb")
SI.MicroWeber.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uWb")

SI.TeraTesla <T SI.Unit
SI.TeraTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TT")
SI.TeraTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TT")

SI.GigaTesla <T SI.Unit
SI.GigaTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GT")
SI.GigaTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GT")

SI.MegaTesla <T SI.Unit
SI.MegaTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MT")
SI.MegaTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MT")

SI.KiloTesla <T SI.Unit
SI.KiloTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kT")
SI.KiloTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kT")

SI.HectoTesla <T SI.Unit
SI.HectoTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hT")
SI.HectoTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hT")

SI.Tesla <T SI.Unit
SI.Tesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="T")
SI.Tesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="T")

SI.CentiTesla <T SI.Unit
SI.CentiTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cT")
SI.CentiTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cT")

SI.MilliTesla <T SI.Unit
SI.MilliTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mT")
SI.MilliTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mT")

SI.MicroTesla <T SI.Unit
SI.MicroTesla.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uT")
SI.MicroTesla.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uT")

SI.TeraHenry <T SI.Unit
SI.TeraHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TH")
SI.TeraHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TH")

SI.GigaHenry <T SI.Unit
SI.GigaHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GH")
SI.GigaHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GH")

SI.MegaHenry <T SI.Unit
SI.MegaHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MH")
SI.MegaHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MH")

SI.KiloHenry <T SI.Unit
SI.KiloHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kH")
SI.KiloHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kH")

SI.HectoHenry <T SI.Unit
SI.HectoHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hH")
SI.HectoHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hH")

SI.Henry <T SI.Unit
SI.Henry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="H")
SI.Henry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="H")

SI.CentiHenry <T SI.Unit
SI.CentiHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cH")
SI.CentiHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cH")

SI.MilliHenry <T SI.Unit
SI.MilliHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mH")
SI.MilliHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mH")

SI.MicroHenry <T SI.Unit
SI.MicroHenry.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uH")
SI.MicroHenry.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uH")

SI.TeraCelsius <T SI.Unit
SI.TeraCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TC")
SI.TeraCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TC")

SI.GigaCelsius <T SI.Unit
SI.GigaCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GC")
SI.GigaCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GC")

SI.MegaCelsius <T SI.Unit
SI.MegaCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MC")
SI.MegaCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MC")

SI.KiloCelsius <T SI.Unit
SI.KiloCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kC")
SI.KiloCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kC")

SI.HectoCelsius <T SI.Unit
SI.HectoCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hC")
SI.HectoCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hC")

SI.Celsius <T SI.Unit
SI.Celsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="C")
SI.Celsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="C")

SI.CentiCelsius <T SI.Unit
SI.CentiCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cC")
SI.CentiCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cC")

SI.MilliCelsius <T SI.Unit
SI.MilliCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mC")
SI.MilliCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mC")

SI.MicroCelsius <T SI.Unit
SI.MicroCelsius.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uC")
SI.MicroCelsius.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uC")

SI.TeraLumen <T SI.Unit
SI.TeraLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tlm")
SI.TeraLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tlm")

SI.GigaLumen <T SI.Unit
SI.GigaLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Glm")
SI.GigaLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Glm")

SI.MegaLumen <T SI.Unit
SI.MegaLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mlm")
SI.MegaLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mlm")

SI.KiloLumen <T SI.Unit
SI.KiloLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="klm")
SI.KiloLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="klm")

SI.HectoLumen <T SI.Unit
SI.HectoLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hlm")
SI.HectoLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hlm")

SI.Lumen <T SI.Unit
SI.Lumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="lm")
SI.Lumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="lm")

SI.CentiLumen <T SI.Unit
SI.CentiLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="clm")
SI.CentiLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="clm")

SI.MilliLumen <T SI.Unit
SI.MilliLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mlm")
SI.MilliLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mlm")

SI.MicroLumen <T SI.Unit
SI.MicroLumen.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ulm")
SI.MicroLumen.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ulm")

SI.TeraLux <T SI.Unit
SI.TeraLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tlx")
SI.TeraLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tlx")

SI.GigaLux <T SI.Unit
SI.GigaLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Glx")
SI.GigaLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Glx")

SI.MegaLux <T SI.Unit
SI.MegaLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mlx")
SI.MegaLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mlx")

SI.KiloLux <T SI.Unit
SI.KiloLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="klx")
SI.KiloLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="klx")

SI.HectoLux <T SI.Unit
SI.HectoLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hlx")
SI.HectoLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hlx")

SI.Lux <T SI.Unit
SI.Lux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="lx")
SI.Lux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="lx")

SI.CentiLux <T SI.Unit
SI.CentiLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="clx")
SI.CentiLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="clx")

SI.MilliLux <T SI.Unit
SI.MilliLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mlx")
SI.MilliLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mlx")

SI.MicroLux <T SI.Unit
SI.MicroLux.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ulx")
SI.MicroLux.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ulx")

SI.TeraBecquerel <T SI.Unit
SI.TeraBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TBq")
SI.TeraBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TBq")

SI.GigaBecquerel <T SI.Unit
SI.GigaBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GBq")
SI.GigaBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GBq")

SI.MegaBecquerel <T SI.Unit
SI.MegaBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MBq")
SI.MegaBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MBq")

SI.KiloBecquerel <T SI.Unit
SI.KiloBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kBq")
SI.KiloBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kBq")

SI.HectoBecquerel <T SI.Unit
SI.HectoBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hBq")
SI.HectoBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hBq")

SI.Becquerel <T SI.Unit
SI.Becquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Bq")
SI.Becquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Bq")

SI.CentiBecquerel <T SI.Unit
SI.CentiBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cBq")
SI.CentiBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cBq")

SI.MilliBecquerel <T SI.Unit
SI.MilliBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mBq")
SI.MilliBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mBq")

SI.MicroBecquerel <T SI.Unit
SI.MicroBecquerel.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uBq")
SI.MicroBecquerel.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uBq")

SI.TeraGray <T SI.Unit
SI.TeraGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TGy")
SI.TeraGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TGy")

SI.GigaGray <T SI.Unit
SI.GigaGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GGy")
SI.GigaGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GGy")

SI.MegaGray <T SI.Unit
SI.MegaGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MGy")
SI.MegaGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MGy")

SI.KiloGray <T SI.Unit
SI.KiloGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kGy")
SI.KiloGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kGy")

SI.HectoGray <T SI.Unit
SI.HectoGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hGy")
SI.HectoGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hGy")

SI.Gray <T SI.Unit
SI.Gray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gy")
SI.Gray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gy")

SI.CentiGray <T SI.Unit
SI.CentiGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cGy")
SI.CentiGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cGy")

SI.MilliGray <T SI.Unit
SI.MilliGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mGy")
SI.MilliGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mGy")

SI.MicroGray <T SI.Unit
SI.MicroGray.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uGy")
SI.MicroGray.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uGy")

SI.TeraSievert <T SI.Unit
SI.TeraSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TSv")
SI.TeraSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TSv")

SI.GigaSievert <T SI.Unit
SI.GigaSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GSv")
SI.GigaSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GSv")

SI.MegaSievert <T SI.Unit
SI.MegaSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MSv")
SI.MegaSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MSv")

SI.KiloSievert <T SI.Unit
SI.KiloSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kSv")
SI.KiloSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kSv")

SI.HectoSievert <T SI.Unit
SI.HectoSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hSv")
SI.HectoSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hSv")

SI.Sievert <T SI.Unit
SI.Sievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Sv")
SI.Sievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Sv")

SI.CentiSievert <T SI.Unit
SI.CentiSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cSv")
SI.CentiSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cSv")

SI.MilliSievert <T SI.Unit
SI.MilliSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mSv")
SI.MilliSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mSv")

SI.MicroSievert <T SI.Unit
SI.MicroSievert.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uSv")
SI.MicroSievert.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uSv")

SI.TeraKatal <T SI.Unit
SI.TeraKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tkat")
SI.TeraKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tkat")

SI.GigaKatal <T SI.Unit
SI.GigaKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gkat")
SI.GigaKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gkat")

SI.MegaKatal <T SI.Unit
SI.MegaKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mkat")
SI.MegaKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mkat")

SI.KiloKatal <T SI.Unit
SI.KiloKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kkat")
SI.KiloKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kkat")

SI.HectoKatal <T SI.Unit
SI.HectoKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hkat")
SI.HectoKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hkat")

SI.Katal <T SI.Unit
SI.Katal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kat")
SI.Katal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kat")

SI.CentiKatal <T SI.Unit
SI.CentiKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ckat")
SI.CentiKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ckat")

SI.MilliKatal <T SI.Unit
SI.MilliKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mkat")
SI.MilliKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mkat")

SI.MicroKatal <T SI.Unit
SI.MicroKatal.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ukat")
SI.MicroKatal.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ukat")

// SI scalable compound units

SI.TeragramPerSecond <T SI.Unit
SI.TeragramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tg/s")
SI.TeragramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tg/s")

SI.GigagramPerSecond <T SI.Unit
SI.GigagramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gg/s")
SI.GigagramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gg/s")

SI.MegagramPerSecond <T SI.Unit
SI.MegagramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mg/s")
SI.MegagramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mg/s")

SI.KilogramPerSecond <T SI.Unit
SI.KilogramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kg/s")
SI.KilogramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kg/s")

SI.HectogramPerSecond <T SI.Unit
SI.HectogramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hg/s")
SI.HectogramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hg/s")

SI.gramPerSecond <T SI.Unit
SI.gramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="g/s")
SI.gramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="g/s")

SI.CentigramPerSecond <T SI.Unit
SI.CentigramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cg/s")
SI.CentigramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cg/s")

SI.MilligramPerSecond <T SI.Unit
SI.MilligramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mg/s")
SI.MilligramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mg/s")

SI.MicrogramPerSecond <T SI.Unit
SI.MicrogramPerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ug/s")
SI.MicrogramPerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ug/s")

SI.TeragramPerLitre <T SI.Unit
SI.TeragramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tg/l")
SI.TeragramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tg/l")

SI.GigagramPerLitre <T SI.Unit
SI.GigagramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gg/l")
SI.GigagramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gg/l")

SI.MegagramPerLitre <T SI.Unit
SI.MegagramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mg/l")
SI.MegagramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mg/l")

SI.KilogramPerLitre <T SI.Unit
SI.KilogramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kg/l")
SI.KilogramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kg/l")

SI.HectogramPerLitre <T SI.Unit
SI.HectogramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hg/l")
SI.HectogramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hg/l")

SI.gramPerLitre <T SI.Unit
SI.gramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="g/l")
SI.gramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="g/l")

SI.CentigramPerLitre <T SI.Unit
SI.CentigramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cg/l")
SI.CentigramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cg/l")

SI.MilligramPerLitre <T SI.Unit
SI.MilligramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mg/l")
SI.MilligramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mg/l")

SI.MicrogramPerLitre <T SI.Unit
SI.MicrogramPerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ug/l")
SI.MicrogramPerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ug/l")

SI.TeragramPerCubicMetre <T SI.Unit
SI.TeragramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tg/m3")
SI.TeragramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tg/m3")

SI.GigagramPerCubicMetre <T SI.Unit
SI.GigagramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gg/m3")
SI.GigagramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gg/m3")

SI.MegagramPerCubicMetre <T SI.Unit
SI.MegagramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mg/m3")
SI.MegagramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mg/m3")

SI.KilogramPerCubicMetre <T SI.Unit
SI.KilogramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kg/m3")
SI.KilogramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kg/m3")

SI.HectogramPerCubicMetre <T SI.Unit
SI.HectogramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hg/m3")
SI.HectogramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hg/m3")

SI.gramPerCubicMetre <T SI.Unit
SI.gramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="g/m3")
SI.gramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="g/m3")

SI.CentigramPerCubicMetre <T SI.Unit
SI.CentigramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cg/m3")
SI.CentigramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cg/m3")

SI.MilligramPerCubicMetre <T SI.Unit
SI.MilligramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mg/m3")
SI.MilligramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mg/m3")

SI.MicrogramPerCubicMetre <T SI.Unit
SI.MicrogramPerCubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="ug/m3")
SI.MicrogramPerCubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="ug/m3")

SI.TeraNewtonPerMetre <T SI.Unit
SI.TeraNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TN/m")
SI.TeraNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TN/m")

SI.GigaNewtonPerMetre <T SI.Unit
SI.GigaNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GN/m")
SI.GigaNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GN/m")

SI.MegaNewtonPerMetre <T SI.Unit
SI.MegaNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MN/m")
SI.MegaNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MN/m")

SI.KiloNewtonPerMetre <T SI.Unit
SI.KiloNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kN/m")
SI.KiloNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kN/m")

SI.HectoNewtonPerMetre <T SI.Unit
SI.HectoNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hN/m")
SI.HectoNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hN/m")

SI.NewtonPerMetre <T SI.Unit
SI.NewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="N/m")
SI.NewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="N/m")

SI.CentiNewtonPerMetre <T SI.Unit
SI.CentiNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cN/m")
SI.CentiNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cN/m")

SI.MilliNewtonPerMetre <T SI.Unit
SI.MilliNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mN/m")
SI.MilliNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mN/m")

SI.MicroNewtonPerMetre <T SI.Unit
SI.MicroNewtonPerMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uN/m")
SI.MicroNewtonPerMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uN/m")

SI.TeraJoulePerKilogram <T SI.Unit
SI.TeraJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="TJ/kg")
SI.TeraJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="TJ/kg")

SI.GigaJoulePerKilogram <T SI.Unit
SI.GigaJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="GJ/kg")
SI.GigaJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="GJ/kg")

SI.MegaJoulePerKilogram <T SI.Unit
SI.MegaJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="MJ/kg")
SI.MegaJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="MJ/kg")

SI.KiloJoulePerKilogram <T SI.Unit
SI.KiloJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kJ/kg")
SI.KiloJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kJ/kg")

SI.HectoJoulePerKilogram <T SI.Unit
SI.HectoJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hJ/kg")
SI.HectoJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hJ/kg")

SI.JoulePerKilogram <T SI.Unit
SI.JoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="J/kg")
SI.JoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="J/kg")

SI.CentiJoulePerKilogram <T SI.Unit
SI.CentiJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cJ/kg")
SI.CentiJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cJ/kg")

SI.MilliJoulePerKilogram <T SI.Unit
SI.MilliJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mJ/kg")
SI.MilliJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mJ/kg")

SI.MicroJoulePerKilogram <T SI.Unit
SI.MicroJoulePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="uJ/kg")
SI.MicroJoulePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="uJ/kg")

SI.TeraMetrePerSecond <T SI.Unit
SI.TeraMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tm/s")
SI.TeraMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tm/s")

SI.GigaMetrePerSecond <T SI.Unit
SI.GigaMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gm/s")
SI.GigaMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gm/s")

SI.MegaMetrePerSecond <T SI.Unit
SI.MegaMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mm/s")
SI.MegaMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mm/s")

SI.KiloMetrePerSecond <T SI.Unit
SI.KiloMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="km/s")
SI.KiloMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="km/s")

SI.HectoMetrePerSecond <T SI.Unit
SI.HectoMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hm/s")
SI.HectoMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hm/s")

SI.MetrePerSecond <T SI.Unit
SI.MetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="m/s")
SI.MetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="m/s")

SI.CentiMetrePerSecond <T SI.Unit
SI.CentiMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cm/s")
SI.CentiMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cm/s")

SI.MilliMetrePerSecond <T SI.Unit
SI.MilliMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mm/s")
SI.MilliMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mm/s")

SI.MicroMetrePerSecond <T SI.Unit
SI.MicroMetrePerSecond.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="um/s")
SI.MicroMetrePerSecond.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="um/s")

SI.TeraMolePerLitre <T SI.Unit
SI.TeraMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tmol/l")
SI.TeraMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tmol/l")

SI.GigaMolePerLitre <T SI.Unit
SI.GigaMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gmol/l")
SI.GigaMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gmol/l")

SI.MegaMolePerLitre <T SI.Unit
SI.MegaMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mmol/l")
SI.MegaMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mmol/l")

SI.KiloMolePerLitre <T SI.Unit
SI.KiloMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kmol/l")
SI.KiloMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kmol/l")

SI.HectoMolePerLitre <T SI.Unit
SI.HectoMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hmol/l")
SI.HectoMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hmol/l")

SI.MolePerLitre <T SI.Unit
SI.MolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mol/l")
SI.MolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mol/l")

SI.CentiMolePerLitre <T SI.Unit
SI.CentiMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cmol/l")
SI.CentiMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cmol/l")

SI.MilliMolePerLitre <T SI.Unit
SI.MilliMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mmol/l")
SI.MilliMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mmol/l")

SI.MicroMolePerLitre <T SI.Unit
SI.MicroMolePerLitre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="umol/l")
SI.MicroMolePerLitre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="umol/l")

SI.TeraMolePerKilogram <T SI.Unit
SI.TeraMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Tmol/kg")
SI.TeraMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Tmol/kg")

SI.GigaMolePerKilogram <T SI.Unit
SI.GigaMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Gmol/kg")
SI.GigaMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Gmol/kg")

SI.MegaMolePerKilogram <T SI.Unit
SI.MegaMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="Mmol/kg")
SI.MegaMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="Mmol/kg")

SI.KiloMolePerKilogram <T SI.Unit
SI.KiloMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="kmol/kg")
SI.KiloMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="kmol/kg")

SI.HectoMolePerKilogram <T SI.Unit
SI.HectoMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="hmol/kg")
SI.HectoMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="hmol/kg")

SI.MolePerKilogram <T SI.Unit
SI.MolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mol/kg")
SI.MolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mol/kg")

SI.CentiMolePerKilogram <T SI.Unit
SI.CentiMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="cmol/kg")
SI.CentiMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="cmol/kg")

SI.MilliMolePerKilogram <T SI.Unit
SI.MilliMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="mmol/kg")
SI.MilliMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="mmol/kg")

SI.MicroMolePerKilogram <T SI.Unit
SI.MicroMolePerKilogram.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="umol/kg")
SI.MicroMolePerKilogram.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="umol/kg")

// SI compound units

SI.SquareMetre <T SI.Unit
SI.SquareMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="m2")
SI.SquareMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="m2")

SI.CubicMetre <T SI.Unit
SI.CubicMetre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="m3")
SI.CubicMetre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="m3")

// Special units

SI.MassPercentage <T SI.Unit
SI.MassPercentage.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="w-%")
SI.MassPercentage.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="w-%")

SI.Percentage <T SI.Unit
SI.Percentage.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="%")
SI.Percentage.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="%")

SI.Degree <T SI.Unit
SI.Degree.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="deg")
SI.Degree.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="deg")

SI.Minute <T SI.Unit
SI.Minute.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="min")
SI.Minute.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="min")

SI.Hour <T SI.Unit
SI.Hour.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="h")
SI.Hour.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="h")

SI.Litre <T SI.Unit
SI.Litre.Double <T L0.Double
  @L0.assert L0.HasDataType $Double(unit="l")
SI.Litre.Float <T L0.Float
  @L0.assert L0.HasDataType $Float(unit="l")