Extend quantities by some SI prefix (#570)

* Extend magnetic field by nano, micro and milli tesla

* Extend electrical inductance by nano, micro, milli henry

* Exten capacitance by pico, nano, micro and milli farad

* Extend eletric resistance by gigaohm

* Extend Pressure by Giga pascal

* Extend amoutof substance by megamol

Author: zykovaa-eplan

Common/GeneratedCode/Quantities/AmountOfSubstance.Common.g.cs

@@ -191,6 +191,11 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public double KilopoundMoles => As(AmountOfSubstanceUnit.KilopoundMole);
 
+        /// <summary>
+        ///     Get AmountOfSubstance in Megamoles.
+        /// </summary>
+        public double Megamoles => As(AmountOfSubstanceUnit.Megamole);
+
         /// <summary>
         ///     Get AmountOfSubstance in Micromoles.
         /// </summary>
@@ -324,6 +329,20 @@ public static AmountOfSubstance FromKilopoundMoles(QuantityValue kilopoundmoles)
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole);
         }
 
+        /// <summary>
+        ///     Get AmountOfSubstance from Megamoles.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static AmountOfSubstance FromMegamoles(double megamoles)
+#else
+        public static AmountOfSubstance FromMegamoles(QuantityValue megamoles)
+#endif
+        {
+            double value = (double) megamoles;
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole);
+        }
+
         /// <summary>
         ///     Get AmountOfSubstance from Micromoles.
         /// </summary>
@@ -614,6 +633,7 @@ private double AsBaseUnit()
                 case AmountOfSubstanceUnit.DecipoundMole: return (_value*453.59237) * 1e-1d;
                 case AmountOfSubstanceUnit.Kilomole: return (_value) * 1e3d;
                 case AmountOfSubstanceUnit.KilopoundMole: return (_value*453.59237) * 1e3d;
+                case AmountOfSubstanceUnit.Megamole: return (_value) * 1e6d;
                 case AmountOfSubstanceUnit.Micromole: return (_value) * 1e-6d;
                 case AmountOfSubstanceUnit.MicropoundMole: return (_value*453.59237) * 1e-6d;
                 case AmountOfSubstanceUnit.Millimole: return (_value) * 1e-3d;
@@ -642,6 +662,7 @@ private double AsBaseNumericType(AmountOfSubstanceUnit unit)
                 case AmountOfSubstanceUnit.DecipoundMole: return (baseUnitValue/453.59237) / 1e-1d;
                 case AmountOfSubstanceUnit.Kilomole: return (baseUnitValue) / 1e3d;
                 case AmountOfSubstanceUnit.KilopoundMole: return (baseUnitValue/453.59237) / 1e3d;
+                case AmountOfSubstanceUnit.Megamole: return (baseUnitValue) / 1e6d;
                 case AmountOfSubstanceUnit.Micromole: return (baseUnitValue) / 1e-6d;
                 case AmountOfSubstanceUnit.MicropoundMole: return (baseUnitValue/453.59237) / 1e-6d;
                 case AmountOfSubstanceUnit.Millimole: return (baseUnitValue) / 1e-3d;

Common/GeneratedCode/Quantities/Capacitance.Common.g.cs

@@ -166,6 +166,26 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public double Farads => As(CapacitanceUnit.Farad);
 
+        /// <summary>
+        ///     Get Capacitance in Microfarads.
+        /// </summary>
+        public double Microfarads => As(CapacitanceUnit.Microfarad);
+
+        /// <summary>
+        ///     Get Capacitance in Millifarads.
+        /// </summary>
+        public double Millifarads => As(CapacitanceUnit.Millifarad);
+
+        /// <summary>
+        ///     Get Capacitance in Nanofarads.
+        /// </summary>
+        public double Nanofarads => As(CapacitanceUnit.Nanofarad);
+
+        /// <summary>
+        ///     Get Capacitance in Picofarads.
+        /// </summary>
+        public double Picofarads => As(CapacitanceUnit.Picofarad);
+
         #endregion
 
         #region Static
@@ -189,6 +209,62 @@ public static Capacitance FromFarads(QuantityValue farads)
             return new Capacitance(value, CapacitanceUnit.Farad);
         }
 
+        /// <summary>
+        ///     Get Capacitance from Microfarads.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Capacitance FromMicrofarads(double microfarads)
+#else
+        public static Capacitance FromMicrofarads(QuantityValue microfarads)
+#endif
+        {
+            double value = (double) microfarads;
+            return new Capacitance(value, CapacitanceUnit.Microfarad);
+        }
+
+        /// <summary>
+        ///     Get Capacitance from Millifarads.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Capacitance FromMillifarads(double millifarads)
+#else
+        public static Capacitance FromMillifarads(QuantityValue millifarads)
+#endif
+        {
+            double value = (double) millifarads;
+            return new Capacitance(value, CapacitanceUnit.Millifarad);
+        }
+
+        /// <summary>
+        ///     Get Capacitance from Nanofarads.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Capacitance FromNanofarads(double nanofarads)
+#else
+        public static Capacitance FromNanofarads(QuantityValue nanofarads)
+#endif
+        {
+            double value = (double) nanofarads;
+            return new Capacitance(value, CapacitanceUnit.Nanofarad);
+        }
+
+        /// <summary>
+        ///     Get Capacitance from Picofarads.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Capacitance FromPicofarads(double picofarads)
+#else
+        public static Capacitance FromPicofarads(QuantityValue picofarads)
+#endif
+        {
+            double value = (double) picofarads;
+            return new Capacitance(value, CapacitanceUnit.Picofarad);
+        }
+
 
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="CapacitanceUnit" /> to <see cref="Capacitance" />.
@@ -362,6 +438,10 @@ private double AsBaseUnit()
             switch(Unit)
             {
                 case CapacitanceUnit.Farad: return _value;
+                case CapacitanceUnit.Microfarad: return (_value) * 1e-6d;
+                case CapacitanceUnit.Millifarad: return (_value) * 1e-3d;
+                case CapacitanceUnit.Nanofarad: return (_value) * 1e-9d;
+                case CapacitanceUnit.Picofarad: return (_value) * 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -377,6 +457,10 @@ private double AsBaseNumericType(CapacitanceUnit unit)
             switch(unit)
             {
                 case CapacitanceUnit.Farad: return baseUnitValue;
+                case CapacitanceUnit.Microfarad: return (baseUnitValue) / 1e-6d;
+                case CapacitanceUnit.Millifarad: return (baseUnitValue) / 1e-3d;
+                case CapacitanceUnit.Nanofarad: return (baseUnitValue) / 1e-9d;
+                case CapacitanceUnit.Picofarad: return (baseUnitValue) / 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
             }

Common/GeneratedCode/Quantities/ElectricInductance.Common.g.cs

@@ -166,6 +166,21 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public double Henries => As(ElectricInductanceUnit.Henry);
 
+        /// <summary>
+        ///     Get ElectricInductance in Microhenries.
+        /// </summary>
+        public double Microhenries => As(ElectricInductanceUnit.Microhenry);
+
+        /// <summary>
+        ///     Get ElectricInductance in Millihenries.
+        /// </summary>
+        public double Millihenries => As(ElectricInductanceUnit.Millihenry);
+
+        /// <summary>
+        ///     Get ElectricInductance in Nanohenries.
+        /// </summary>
+        public double Nanohenries => As(ElectricInductanceUnit.Nanohenry);
+
         #endregion
 
         #region Static
@@ -189,6 +204,48 @@ public static ElectricInductance FromHenries(QuantityValue henries)
             return new ElectricInductance(value, ElectricInductanceUnit.Henry);
         }
 
+        /// <summary>
+        ///     Get ElectricInductance from Microhenries.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static ElectricInductance FromMicrohenries(double microhenries)
+#else
+        public static ElectricInductance FromMicrohenries(QuantityValue microhenries)
+#endif
+        {
+            double value = (double) microhenries;
+            return new ElectricInductance(value, ElectricInductanceUnit.Microhenry);
+        }
+
+        /// <summary>
+        ///     Get ElectricInductance from Millihenries.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static ElectricInductance FromMillihenries(double millihenries)
+#else
+        public static ElectricInductance FromMillihenries(QuantityValue millihenries)
+#endif
+        {
+            double value = (double) millihenries;
+            return new ElectricInductance(value, ElectricInductanceUnit.Millihenry);
+        }
+
+        /// <summary>
+        ///     Get ElectricInductance from Nanohenries.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static ElectricInductance FromNanohenries(double nanohenries)
+#else
+        public static ElectricInductance FromNanohenries(QuantityValue nanohenries)
+#endif
+        {
+            double value = (double) nanohenries;
+            return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry);
+        }
+
 
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="ElectricInductanceUnit" /> to <see cref="ElectricInductance" />.
@@ -362,6 +419,9 @@ private double AsBaseUnit()
             switch(Unit)
             {
                 case ElectricInductanceUnit.Henry: return _value;
+                case ElectricInductanceUnit.Microhenry: return (_value) * 1e-6d;
+                case ElectricInductanceUnit.Millihenry: return (_value) * 1e-3d;
+                case ElectricInductanceUnit.Nanohenry: return (_value) * 1e-9d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -377,6 +437,9 @@ private double AsBaseNumericType(ElectricInductanceUnit unit)
             switch(unit)
             {
                 case ElectricInductanceUnit.Henry: return baseUnitValue;
+                case ElectricInductanceUnit.Microhenry: return (baseUnitValue) / 1e-6d;
+                case ElectricInductanceUnit.Millihenry: return (baseUnitValue) / 1e-3d;
+                case ElectricInductanceUnit.Nanohenry: return (baseUnitValue) / 1e-9d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
             }

Common/GeneratedCode/Quantities/ElectricResistance.Common.g.cs

@@ -161,6 +161,11 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public static ElectricResistanceUnit[] Units { get; } = Enum.GetValues(typeof(ElectricResistanceUnit)).Cast<ElectricResistanceUnit>().Except(new ElectricResistanceUnit[]{ ElectricResistanceUnit.Undefined }).ToArray();
 
+        /// <summary>
+        ///     Get ElectricResistance in Gigaohms.
+        /// </summary>
+        public double Gigaohms => As(ElectricResistanceUnit.Gigaohm);
+
         /// <summary>
         ///     Get ElectricResistance in Kiloohms.
         /// </summary>
@@ -190,6 +195,20 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public static ElectricResistance Zero => new ElectricResistance(0, BaseUnit);
 
+        /// <summary>
+        ///     Get ElectricResistance from Gigaohms.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static ElectricResistance FromGigaohms(double gigaohms)
+#else
+        public static ElectricResistance FromGigaohms(QuantityValue gigaohms)
+#endif
+        {
+            double value = (double) gigaohms;
+            return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm);
+        }
+
         /// <summary>
         ///     Get ElectricResistance from Kiloohms.
         /// </summary>
@@ -418,6 +437,7 @@ private double AsBaseUnit()
         {
             switch(Unit)
             {
+                case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d;
                 case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d;
                 case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d;
                 case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d;
@@ -436,6 +456,7 @@ private double AsBaseNumericType(ElectricResistanceUnit unit)
 
             switch(unit)
             {
+                case ElectricResistanceUnit.Gigaohm: return (baseUnitValue) / 1e9d;
                 case ElectricResistanceUnit.Kiloohm: return (baseUnitValue) / 1e3d;
                 case ElectricResistanceUnit.Megaohm: return (baseUnitValue) / 1e6d;
                 case ElectricResistanceUnit.Milliohm: return (baseUnitValue) / 1e-3d;

Common/GeneratedCode/Quantities/MagneticField.Common.g.cs

@@ -161,6 +161,21 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public static MagneticFieldUnit[] Units { get; } = Enum.GetValues(typeof(MagneticFieldUnit)).Cast<MagneticFieldUnit>().Except(new MagneticFieldUnit[]{ MagneticFieldUnit.Undefined }).ToArray();
 
+        /// <summary>
+        ///     Get MagneticField in Microteslas.
+        /// </summary>
+        public double Microteslas => As(MagneticFieldUnit.Microtesla);
+
+        /// <summary>
+        ///     Get MagneticField in Milliteslas.
+        /// </summary>
+        public double Milliteslas => As(MagneticFieldUnit.Millitesla);
+
+        /// <summary>
+        ///     Get MagneticField in Nanoteslas.
+        /// </summary>
+        public double Nanoteslas => As(MagneticFieldUnit.Nanotesla);
+
         /// <summary>
         ///     Get MagneticField in Teslas.
         /// </summary>
@@ -175,6 +190,48 @@ public static BaseDimensions BaseDimensions
         /// </summary>
         public static MagneticField Zero => new MagneticField(0, BaseUnit);
 
+        /// <summary>
+        ///     Get MagneticField from Microteslas.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static MagneticField FromMicroteslas(double microteslas)
+#else
+        public static MagneticField FromMicroteslas(QuantityValue microteslas)
+#endif
+        {
+            double value = (double) microteslas;
+            return new MagneticField(value, MagneticFieldUnit.Microtesla);
+        }
+
+        /// <summary>
+        ///     Get MagneticField from Milliteslas.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static MagneticField FromMilliteslas(double milliteslas)
+#else
+        public static MagneticField FromMilliteslas(QuantityValue milliteslas)
+#endif
+        {
+            double value = (double) milliteslas;
+            return new MagneticField(value, MagneticFieldUnit.Millitesla);
+        }
+
+        /// <summary>
+        ///     Get MagneticField from Nanoteslas.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static MagneticField FromNanoteslas(double nanoteslas)
+#else
+        public static MagneticField FromNanoteslas(QuantityValue nanoteslas)
+#endif
+        {
+            double value = (double) nanoteslas;
+            return new MagneticField(value, MagneticFieldUnit.Nanotesla);
+        }
+
         /// <summary>
         ///     Get MagneticField from Teslas.
         /// </summary>
@@ -361,6 +418,9 @@ private double AsBaseUnit()
         {
             switch(Unit)
             {
+                case MagneticFieldUnit.Microtesla: return (_value) * 1e-6d;
+                case MagneticFieldUnit.Millitesla: return (_value) * 1e-3d;
+                case MagneticFieldUnit.Nanotesla: return (_value) * 1e-9d;
                 case MagneticFieldUnit.Tesla: return _value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
@@ -376,6 +436,9 @@ private double AsBaseNumericType(MagneticFieldUnit unit)
 
             switch(unit)
             {
+                case MagneticFieldUnit.Microtesla: return (baseUnitValue) / 1e-6d;
+                case MagneticFieldUnit.Millitesla: return (baseUnitValue) / 1e-3d;
+                case MagneticFieldUnit.Nanotesla: return (baseUnitValue) / 1e-9d;
                 case MagneticFieldUnit.Tesla: return baseUnitValue;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to {unit}.");